ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Matroid.Indep.not_mem_closure_iff
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
he : autoParam (e ∈ M.E) _auto✝
⊢ e ∉ M.closure I ↔ M.Indep (insert e I) ∧ e ∉ I
state_after: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
he : autoParam (e ∈ M.E) _auto✝
⊢ ¬(¬M.Indep (insert e I) ∨ e ∈ I) ↔ M.Indep (insert e I) ∧ e ∉ I
tactic: rw [hI.mem_closure_iff, dep_iff, insert_subset_iff, and_iff_right he,
    and_iff_left hI.subset_ground]
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
he : autoParam (e ∈ M.E) _auto✝
⊢ ¬(¬M.Indep (insert e I) ∨ e ∈ I) ↔ M.Indep (insert e I) ∧ e ∉ I
state_after: no goals
tactic: tauto
Theorem: Array.join_data
File: .lake/packages/batteries/Batteries/Data/Array/Lemmas.lean

Proof steps:
state_before: α : Type u_1
l : Array (Array α)
⊢ l.join.data = (List.map data l.data).join
state_after: α : Type u_1
l : Array (Array α)
⊢ (foldl (fun x x_1 => x ++ x_1) #[] l 0).data = (List.map data l.data).join
tactic: dsimp [join]
state_before: α : Type u_1
l : Array (Array α)
⊢ (foldl (fun x x_1 => x ++ x_1) #[] l 0).data = (List.map data l.data).join
state_after: α : Type u_1
l : Array (Array α)
⊢ (List.foldl (fun x x_1 => x ++ x_1) #[] l.data).data = (List.map data l.data).join
tactic: simp only [foldl_eq_foldl_data]
state_before: α : Type u_1
l : Array (Array α)
⊢ (List.foldl (fun x x_1 => x ++ x_1) #[] l.data).data = (List.map data l.data).join
state_after: α : Type u_1
l✝ : Array (Array α)
l : List (Array α)
⊢ (List.foldl (fun x x_1 => x ++ x_1) #[] l).data = (List.map data l).join
tactic: generalize l.data = l
state_before: α : Type u_1
l✝ : Array (Array α)
l : List (Array α)
⊢ (List.foldl (fun x x_1 => x ++ x_1) #[] l).data = (List.map data l).join
state_after: case refine_4
α : Type u_1
l✝ : Array (Array α)
l : List (Array α)
this : ∀ (a : Array α), (List.foldl (?m.43089 a) a l).data = a.data ++ ?m.43090 a
⊢ (List.foldl (fun x x_1 => x ++ x_1) #[] l).data = (List.map data l).join

case refine_1
α : Type u_1
l✝ : Array (Array α)
l : List (Array α)
a : Array α
⊢ Array α → Array α → Array α

case refine_2
α : Type u_1
l✝ : Array (Array α)
l : List (Array α)
a : Array α
⊢ List α

case refine_3
α : Type u_1
l✝ : Array (Array α)
l : List (Array α)
⊢ ∀ (a : Array α), (List.foldl (?m.43089 a) a l).data = a.data ++ ?m.43090 a
tactic: have : ∀ a : Array α, (List.foldl ?_ a l).data = a.data ++ ?_ := ?_
state_before: case refine_4
α : Type u_1
l✝ : Array (Array α)
l : List (Array α)
this : ∀ (a : Array α), (List.foldl (?m.43089 a) a l).data = a.data ++ ?m.43090 a
⊢ (List.foldl (fun x x_1 => x ++ x_1) #[] l).data = (List.map data l).join

case refine_1
α : Type u_1
l✝ : Array (Array α)
l : List (Array α)
a : Array α
⊢ Array α → Array α → Array α

case refine_2
α : Type u_1
l✝ : Array (Array α)
l : List (Array α)
a : Array α
⊢ List α

case refine_3
α : Type u_1
l✝ : Array (Array α)
l : List (Array α)
⊢ ∀ (a : Array α), (List.foldl (?m.43089 a) a l).data = a.data ++ ?m.43090 a
state_after: case refine_3
α : Type u_1
l✝ : Array (Array α)
l : List (Array α)
⊢ ∀ (a : Array α), (List.foldl (fun x x_1 => x ++ x_1) a l).data = a.data ++ (List.map data l).join
tactic: exact this #[]
state_before: case refine_3
α : Type u_1
l✝ : Array (Array α)
l : List (Array α)
⊢ ∀ (a : Array α), (List.foldl (fun x x_1 => x ++ x_1) a l).data = a.data ++ (List.map data l).join
state_after: no goals
tactic: induction l with
  | nil => simp
  | cons h => induction h.data <;> simp [*]
Theorem: QuotientAddGroup.map_mk'_self
File: Mathlib/GroupTheory/QuotientGroup.lean

Proof steps:
state_before: G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
⊢ Subgroup.map (mk' N) N = ⊥
state_after: no goals
tactic: aesop
Theorem: sameRay_neg_smul_right_iff_of_ne
File: Mathlib/LinearAlgebra/Ray.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : LinearOrderedCommRing R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
v : M
r : R
hv : v ≠ 0
hr : r ≠ 0
⊢ SameRay R (-v) (r • v) ↔ r < 0
state_after: no goals
tactic: simp only [sameRay_neg_smul_right_iff, hv, or_false_iff, hr.le_iff_lt]
Theorem: QuotientAddGroup.isOpenMap_coe
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
N : Subgroup G
n : N.Normal
⊢ IsOpenMap mk
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
N : Subgroup G
n : N.Normal
s : Set G
s_op : IsOpen s
⊢ IsOpen (mk '' s)
tactic: intro s s_op
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
N : Subgroup G
n : N.Normal
s : Set G
s_op : IsOpen s
⊢ IsOpen (mk '' s)
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
N : Subgroup G
n : N.Normal
s : Set G
s_op : IsOpen s
⊢ IsOpen (mk ⁻¹' (mk '' s))
tactic: change IsOpen (((↑) : G → G ⧸ N) ⁻¹' ((↑) '' s))
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
N : Subgroup G
n : N.Normal
s : Set G
s_op : IsOpen s
⊢ IsOpen (mk ⁻¹' (mk '' s))
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
N : Subgroup G
n : N.Normal
s : Set G
s_op : IsOpen s
⊢ IsOpen (⋃ x, (fun x_1 => x_1 * ↑x) ⁻¹' s)
tactic: rw [QuotientGroup.preimage_image_mk N s]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
N : Subgroup G
n : N.Normal
s : Set G
s_op : IsOpen s
⊢ IsOpen (⋃ x, (fun x_1 => x_1 * ↑x) ⁻¹' s)
state_after: no goals
tactic: exact isOpen_iUnion fun n => (continuous_mul_right _).isOpen_preimage s s_op
Theorem: multipliable_of_finite_mulSupport
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
h : (mulSupport f).Finite
⊢ Multipliable f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
h : (mulSupport f).Finite
⊢ ∀ b ∉ h.toFinset, f b = 1
tactic: apply multipliable_of_ne_finset_one (s := h.toFinset)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
h : (mulSupport f).Finite
⊢ ∀ b ∉ h.toFinset, f b = 1
state_after: no goals
tactic: simp
Theorem: List.lookmap.go_append
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
l : List α
acc : Array α
⊢ go f l acc = acc.toListAppend (lookmap f l)
state_after: no goals
tactic: cases l with
  | nil => rfl
  | cons hd tl =>
    rw [lookmap, go, go]
    cases f hd with
    | none => simp only [go_append tl _, Array.toListAppend_eq, append_assoc, Array.push_data]; rfl
    | some a => rfl
Theorem: Fin.castLE_inj
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
hmn : m ≤ n
a b : Fin m
⊢ castLE hmn a = castLE hmn b ↔ a = b
state_after: no goals
tactic: simp [Fin.ext_iff]
Theorem: continuousMul_iInf
File: Mathlib/Topology/Algebra/Monoid.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝¹ : TopologicalSpace X
ι' : Sort u_6
inst✝ : Mul M
ts : ι' → TopologicalSpace M
h' : ∀ (i : ι'), ContinuousMul M
⊢ ContinuousMul M
state_after: no goals
tactic: exact continuousMul_sInf (Set.forall_mem_range.mpr h')
Theorem: Filter.map_map₂_distrib
File: Mathlib/Order/Filter/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
n : γ → δ
m' : α' → β' → δ
n₁ : α → α'
n₂ : β → β'
h_distrib : ∀ (a : α) (b : β), n (m a b) = m' (n₁ a) (n₂ b)
⊢ map n (map₂ m f g) = map₂ m' (map n₁ f) (map n₂ g)
state_after: no goals
tactic: simp_rw [map_map₂, map₂_map_left, map₂_map_right, h_distrib]
Theorem: dist_sub_left
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

Proof steps:
state_before: M : Type u
G : Type v
X : Type w
inst✝³ : Group G
inst✝² : PseudoMetricSpace G
inst✝¹ : IsometricSMul G G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b c : G
⊢ dist (a / b) (a / c) = dist b c
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: Ordinal.one_add_of_omega_le
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
h : ω ≤ o
⊢ 1 + o = o
state_after: no goals
tactic: rw [← Ordinal.add_sub_cancel_of_le h, ← add_assoc, one_add_omega]
Theorem: Finset.filter_cons
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
s✝ t : Finset α
a : α
s : Finset α
ha : a ∉ s
⊢ _root_.Disjoint (if p a then {a} else ∅) (filter p s)
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
s✝ t : Finset α
a : α
s : Finset α
ha : a ∉ s
h✝ : p a
⊢ _root_.Disjoint {a} (filter p s)

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
s✝ t : Finset α
a : α
s : Finset α
ha : a ∉ s
h✝ : ¬p a
⊢ _root_.Disjoint ∅ (filter p s)
tactic: split_ifs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
s✝ t : Finset α
a : α
s : Finset α
ha : a ∉ s
⊢ filter p (cons a s ha) = (if p a then {a} else ∅).disjUnion (filter p s) ⋯
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
s✝ t : Finset α
a : α
s : Finset α
ha : a ∉ s
h : p a
⊢ filter p (cons a s ha) = {a}.disjUnion (filter p s) ⋯

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
s✝ t : Finset α
a : α
s : Finset α
ha : a ∉ s
h : ¬p a
⊢ filter p (cons a s ha) = ∅.disjUnion (filter p s) ⋯
tactic: split_ifs with h
Theorem: Set.Icc_inter_Icc_eq_singleton
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : Lattice α
a b c a₁ a₂ b₁ b₂ : α
hab : a ≤ b
hbc : b ≤ c
⊢ Icc a b ∩ Icc b c = {b}
state_after: no goals
tactic: rw [Icc_inter_Icc, sup_of_le_right hab, inf_of_le_left hbc, Icc_self]
Theorem: zsmul_mono_right
File: Mathlib/Algebra/Order/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedCommGroup α
m n : ℤ
a✝ b✝ : α
hn : 0 ≤ n
a b : α
hab : a ≤ b
⊢ (fun x => x ^ n) a ≤ (fun x => x ^ n) b
state_after: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedCommGroup α
m n : ℤ
a✝ b✝ : α
hn : 0 ≤ n
a b : α
hab : a ≤ b
⊢ 1 ≤ (b / a) ^ n
tactic: rw [← one_le_div', ← div_zpow]
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedCommGroup α
m n : ℤ
a✝ b✝ : α
hn : 0 ≤ n
a b : α
hab : a ≤ b
⊢ 1 ≤ (b / a) ^ n
state_after: no goals
tactic: exact one_le_zpow (one_le_div'.2 hab) hn
Theorem: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.ite_pos
File: Mathlib/Tactic/Positivity/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Zero α
p : Prop
inst✝¹ : Decidable p
a b : α
inst✝ : LT α
ha : 0 < a
hb : 0 < b
⊢ 0 < if p then a else b
state_after: no goals
tactic: by_cases p <;> simp [*]
Theorem: CategoryTheory.ShortComplex.LeftHomologyMapData.ofIsColimitCokernelCofork_φH
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.61855, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
φ✝ : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
φ : S₁ ⟶ S₂
hg₁ : S₁.g = 0
c₁ : CokernelCofork S₁.f
hc₁ : IsColimit c₁
hg₂ : S₂.g = 0
c₂ : CokernelCofork S₂.f
hc₂ : IsColimit c₂
f : c₁.pt ⟶ c₂.pt
comm : φ.τ₂ ≫ Cofork.π c₂ = Cofork.π c₁ ≫ f
⊢ (LeftHomologyData.ofIsColimitCokernelCofork S₁ hg₁ c₁ hc₁).f' ≫ φ.τ₂ =
    φ.τ₁ ≫ (LeftHomologyData.ofIsColimitCokernelCofork S₂ hg₂ c₂ hc₂).f'
state_after: no goals
tactic: simp only [LeftHomologyData.ofIsColimitCokernelCofork_f', φ.comm₁₂]
Theorem: Set.neg_smul_set
File: Mathlib/Data/Set/Pointwise/SMul.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Ring α
inst✝¹ : AddCommGroup β
inst✝ : Module α β
a : α
s : Set α
t : Set β
⊢ -a • t = -(a • t)
state_after: no goals
tactic: simp_rw [← image_smul, ← image_neg, image_image, neg_smul]
Theorem: IndexedPartition.iUnion
File: Mathlib/Data/Setoid/Partition.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
s : ι → Set α
hs : IndexedPartition s
⊢ ⋃ i, s i = univ
state_after: case h
ι : Type u_1
α : Type u_2
s : ι → Set α
hs : IndexedPartition s
x : α
⊢ x ∈ ⋃ i, s i ↔ x ∈ univ
tactic: ext x
state_before: case h
ι : Type u_1
α : Type u_2
s : ι → Set α
hs : IndexedPartition s
x : α
⊢ x ∈ ⋃ i, s i ↔ x ∈ univ
state_after: no goals
tactic: simp [hs.exists_mem x]
Theorem: CategoryTheory.ShortComplex.SnakeInput.lift_φ₂
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
A : C
a : A ⟶ S.L₁.X₂
b : A ⟶ S.L₀.X₃
h : a ≫ S.L₁.g = b ≫ S.v₀₁.τ₃
⊢ pullback.lift a b h ≫ S.φ₂ = a ≫ S.v₁₂.τ₂
state_after: no goals
tactic: simp [φ₂]
Theorem: MeasureTheory.AEStronglyMeasurable.ae_integrable_condDistrib_map_iff
File: Mathlib/Probability/Kernel/CondDistrib.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
hY : AEMeasurable Y μ
hf : AEStronglyMeasurable f (Measure.map (fun a => (X a, Y a)) μ)
⊢ (∀ᵐ (a : β) ∂Measure.map X μ, Integrable (fun ω => f (a, ω)) ((condDistrib Y X μ) a)) ∧
      Integrable (fun a => ∫ (ω : Ω), ‖f (a, ω)‖ ∂(condDistrib Y X μ) a) (Measure.map X μ) ↔
    Integrable f (Measure.map (fun a => (X a, Y a)) μ)
state_after: no goals
tactic: rw [condDistrib, ← hf.ae_integrable_condKernel_iff, Measure.fst_map_prod_mk₀ hY]
Theorem: Subgroup.subsingleton_iff
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
h : Subsingleton G
x y : Subgroup G
i : G
⊢ 1 ∈ x ↔ 1 ∈ y
state_after: no goals
tactic: simp [Subgroup.one_mem]
Theorem: CategoryTheory.Grothendieck.id_fiber
File: Mathlib/CategoryTheory/Grothendieck.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.4689, u_1} C
inst✝ : Category.{?u.4693, u_2} D
F : C ⥤ Cat
X : Grothendieck F
⊢ (F.map (𝟙 X.base)).obj X.fiber = X.fiber
state_after: no goals
tactic: erw [CategoryTheory.Functor.map_id, Functor.id_obj X.fiber]
Theorem: existsUnique_sub_zsmul_mem_Ico
File: Mathlib/Algebra/Order/Archimedean.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
a : α
ha : 0 < a
b c : α
⊢ ∃! m, b - m • a ∈ Ico c (c + a)
state_after: no goals
tactic: simpa only [mem_Ico, le_sub_iff_add_le, zero_add, add_comm c, sub_lt_iff_lt_add', add_assoc] using
    existsUnique_zsmul_near_of_pos' ha (b - c)
Theorem: CategoryTheory.Limits.MultispanIndex.ofSigmaCoforkFunctor_map_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Cofork I.fstSigmaMap I.sndSigmaMap
f : K₁ ⟶ K₂
⊢ ∀ (j : WalkingMultispan I.fstFrom I.sndFrom),
    (Multicofork.ofSigmaCofork I K₁).ι.app j ≫ f.hom = (Multicofork.ofSigmaCofork I K₂).ι.app j
state_after: case left
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Cofork I.fstSigmaMap I.sndSigmaMap
f : K₁ ⟶ K₂
a✝ : I.L
⊢ (Multicofork.ofSigmaCofork I K₁).ι.app (WalkingMultispan.left a✝) ≫ f.hom =
    (Multicofork.ofSigmaCofork I K₂).ι.app (WalkingMultispan.left a✝)

case right
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Cofork I.fstSigmaMap I.sndSigmaMap
f : K₁ ⟶ K₂
a✝ : I.R
⊢ (Multicofork.ofSigmaCofork I K₁).ι.app (WalkingMultispan.right a✝) ≫ f.hom =
    (Multicofork.ofSigmaCofork I K₂).ι.app (WalkingMultispan.right a✝)
tactic: rintro (_ | _)
state_before: case left
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Cofork I.fstSigmaMap I.sndSigmaMap
f : K₁ ⟶ K₂
a✝ : I.L
⊢ (Multicofork.ofSigmaCofork I K₁).ι.app (WalkingMultispan.left a✝) ≫ f.hom =
    (Multicofork.ofSigmaCofork I K₂).ι.app (WalkingMultispan.left a✝)

case right
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Cofork I.fstSigmaMap I.sndSigmaMap
f : K₁ ⟶ K₂
a✝ : I.R
⊢ (Multicofork.ofSigmaCofork I K₁).ι.app (WalkingMultispan.right a✝) ≫ f.hom =
    (Multicofork.ofSigmaCofork I K₂).ι.app (WalkingMultispan.right a✝)
state_after: case right
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Cofork I.fstSigmaMap I.sndSigmaMap
f : K₁ ⟶ K₂
a✝ : I.R
⊢ (Multicofork.ofSigmaCofork I K₁).ι.app (WalkingMultispan.right a✝) ≫ f.hom =
    (Multicofork.ofSigmaCofork I K₂).ι.app (WalkingMultispan.right a✝)
tactic: { simp [-Multicofork.fst_app_right] }
state_before: case right
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Cofork I.fstSigmaMap I.sndSigmaMap
f : K₁ ⟶ K₂
a✝ : I.R
⊢ (Multicofork.ofSigmaCofork I K₁).ι.app (WalkingMultispan.right a✝) ≫ f.hom =
    (Multicofork.ofSigmaCofork I K₂).ι.app (WalkingMultispan.right a✝)
state_after: no goals
tactic: { simp [-Multicofork.ofSigmaCofork_pt] }
Theorem: String.get_cons_addChar
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: c : Char
cs : List Char
i : Pos
⊢ { data := c :: cs }.get (i + c) = { data := cs }.get i
state_after: no goals
tactic: simp [get, utf8GetAux, Pos.zero_ne_addChar, utf8GetAux_addChar_right_cancel]
Theorem: Set.smul_set_neg
File: Mathlib/Data/Set/Pointwise/SMul.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Monoid α
inst✝¹ : AddGroup β
inst✝ : DistribMulAction α β
a : α
s : Set α
t : Set β
⊢ a • -t = -(a • t)
state_after: no goals
tactic: simp_rw [← image_smul, ← image_neg, image_image, smul_neg]
Theorem: Projectivization.finrank_submodule
File: Mathlib/LinearAlgebra/Projectivization/Basic.lean

Proof steps:
state_before: K : Type u_1
V : Type u_2
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : ℙ K V
⊢ finrank K ↥v.submodule = 1
state_after: K : Type u_1
V : Type u_2
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : ℙ K V
⊢ finrank K ↥(Submodule.span K {v.rep}) = 1
tactic: rw [submodule_eq]
state_before: K : Type u_1
V : Type u_2
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : ℙ K V
⊢ finrank K ↥(Submodule.span K {v.rep}) = 1
state_after: no goals
tactic: exact finrank_span_singleton v.rep_nonzero
Theorem: padicValRat_two_harmonic
File: Mathlib/NumberTheory/Harmonic/Int.lean

Proof steps:
state_before: n : ℕ
⊢ padicValRat 2 (harmonic n) = -↑(Nat.log 2 n)
state_after: case zero

⊢ padicValRat 2 (harmonic 0) = -↑(Nat.log 2 0)

case succ
n : ℕ
ih : padicValRat 2 (harmonic n) = -↑(Nat.log 2 n)
⊢ padicValRat 2 (harmonic (n + 1)) = -↑(Nat.log 2 (n + 1))
tactic: induction' n with n ih
Theorem: hasLineDerivAt_smul_iff
File: Mathlib/Analysis/Calculus/LineDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
f : E → F
s : Set E
x v : E
f' : F
c : 𝕜
hc : c ≠ 0
h : HasLineDerivAt 𝕜 f (c • f') x (c • v)
⊢ HasLineDerivAt 𝕜 f f' x v
state_after: no goals
tactic: simpa [smul_smul, inv_mul_cancel hc] using h.smul (c ⁻¹)
Theorem: Finsupp.support_inf_union_support_sup
File: Mathlib/Data/Finsupp/Order.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Zero α
inst✝¹ : DecidableEq ι
inst✝ : Lattice α
f g : ι →₀ α
⊢ (↑((f ⊓ g).support ∪ (f ⊔ g).support))ᶜ = (↑(f.support ∪ g.support))ᶜ
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Zero α
inst✝¹ : DecidableEq ι
inst✝ : Lattice α
f g : ι →₀ α
x✝ : ι
⊢ x✝ ∈ (↑((f ⊓ g).support ∪ (f ⊔ g).support))ᶜ ↔ x✝ ∈ (↑(f.support ∪ g.support))ᶜ
tactic: ext
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Zero α
inst✝¹ : DecidableEq ι
inst✝ : Lattice α
f g : ι →₀ α
x✝ : ι
⊢ x✝ ∈ (↑((f ⊓ g).support ∪ (f ⊔ g).support))ᶜ ↔ x✝ ∈ (↑(f.support ∪ g.support))ᶜ
state_after: no goals
tactic: simp [inf_eq_and_sup_eq_iff]
Theorem: Submodule.finrank_add_le_finrank_add_finrank
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K ↥s
inst✝ : FiniteDimensional K ↥t
⊢ finrank K ↥(s ⊔ t) ≤ finrank K ↥s + finrank K ↥t
state_after: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K ↥s
inst✝ : FiniteDimensional K ↥t
⊢ finrank K ↥(s ⊔ t) ≤ finrank K ↥(s ⊔ t) + finrank K ↥(s ⊓ t)
tactic: rw [← finrank_sup_add_finrank_inf_eq]
state_before: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K ↥s
inst✝ : FiniteDimensional K ↥t
⊢ finrank K ↥(s ⊔ t) ≤ finrank K ↥(s ⊔ t) + finrank K ↥(s ⊓ t)
state_after: no goals
tactic: exact self_le_add_right _ _
Theorem: Filter.comap_surjective_eq_bot
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
hm : Surjective m
⊢ comap m f = ⊥ ↔ f = ⊥
state_after: no goals
tactic: rw [comap_eq_bot_iff_compl_range, hm.range_eq, compl_univ, empty_mem_iff_bot]
Theorem: Nat.bodd_add
File: Mathlib/Data/Nat/Bits.lean

Proof steps:
state_before: m✝ n✝ m n : ℕ
⊢ (m + n).bodd = bxor m.bodd n.bodd
state_after: case zero
m✝ n m : ℕ
⊢ (m + 0).bodd = bxor m.bodd (bodd 0)

case succ
m✝ n m n✝ : ℕ
a✝ : (m + n✝).bodd = bxor m.bodd n✝.bodd
⊢ (m + (n✝ + 1)).bodd = bxor m.bodd (n✝ + 1).bodd
tactic: induction n
state_before: case zero
m✝ n m : ℕ
⊢ (m + 0).bodd = bxor m.bodd (bodd 0)

case succ
m✝ n m n✝ : ℕ
a✝ : (m + n✝).bodd = bxor m.bodd n✝.bodd
⊢ (m + (n✝ + 1)).bodd = bxor m.bodd (n✝ + 1).bodd
state_after: case succ
m✝ n m n✝ : ℕ
a✝ : (m + n✝).bodd = bxor m.bodd n✝.bodd
⊢ (m + (n✝ + 1)).bodd = bxor m.bodd (n✝ + 1).bodd
tactic: case zero => simp
state_before: case succ
m✝ n m n✝ : ℕ
a✝ : (m + n✝).bodd = bxor m.bodd n✝.bodd
⊢ (m + (n✝ + 1)).bodd = bxor m.bodd (n✝ + 1).bodd
state_after: no goals
tactic: case succ n ih => simp [← Nat.add_assoc, Bool.xor_not, ih]