ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Matrix.toBilin'_comp
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

Proof steps:
state_before: R : Type u_1
M✝ : Type u_2
inst✝¹⁸ : CommSemiring R
inst✝¹⁷ : AddCommMonoid M✝
inst✝¹⁶ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁵ : CommRing R₁
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹² : CommSemiring R₂
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁹ : CommRing R₃
inst✝⁸ : AddCommGroup M₃
inst✝⁷ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : DecidableEq n
inst✝ : DecidableEq o
M : Matrix n n R₂
P Q : Matrix n o R₂
⊢ BilinForm.toMatrix' ((toBilin' M).comp (toLin' P) (toLin' Q)) = BilinForm.toMatrix' (toBilin' (Pᵀ * M * Q))
state_after: no goals
tactic: simp only [BilinForm.toMatrix'_comp, BilinForm.toMatrix'_toBilin', toMatrix'_toLin']
Theorem: MeasureTheory.inter_ae_eq_empty_of_ae_eq_empty_right
File: Mathlib/MeasureTheory/OuterMeasure/AE.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
h : t =ᶠ[ae μ] ∅
⊢ s ∩ t =ᶠ[ae μ] ∅
state_after: case h.e'_5
α : Type u_1
β : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
h : t =ᶠ[ae μ] ∅
⊢ ∅ = s ∩ ∅
tactic: convert ae_eq_set_inter (ae_eq_refl s) h
state_before: case h.e'_5
α : Type u_1
β : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
h : t =ᶠ[ae μ] ∅
⊢ ∅ = s ∩ ∅
state_after: no goals
tactic: rw [inter_empty]
Theorem: Finset.val_eq_singleton_iff
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ : Finset α
a✝ b a : α
s : Finset α
⊢ s.val = {a} ↔ s = {a}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ : Finset α
a✝ b a : α
s : Finset α
⊢ s.val = {a} ↔ s.val = {a}.val
tactic: rw [← val_inj]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ : Finset α
a✝ b a : α
s : Finset α
⊢ s.val = {a} ↔ s.val = {a}.val
state_after: no goals
tactic: rfl
Theorem: Matroid.Base.nonempty
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B B₁ B₂ : Set α
inst✝ : M.RkPos
hB : M.Base B
⊢ B.Nonempty
state_after: α : Type u_1
M : Matroid α
B B₁ B₂ : Set α
inst✝ : M.RkPos
hB : M.Base B
⊢ B ≠ ∅
tactic: rw [nonempty_iff_ne_empty]
state_before: α : Type u_1
M : Matroid α
B B₁ B₂ : Set α
inst✝ : M.RkPos
hB : M.Base B
⊢ B ≠ ∅
state_after: α : Type u_1
M : Matroid α
B₁ B₂ : Set α
inst✝ : M.RkPos
hB : M.Base ∅
⊢ False
tactic: rintro rfl
state_before: α : Type u_1
M : Matroid α
B₁ B₂ : Set α
inst✝ : M.RkPos
hB : M.Base ∅
⊢ False
state_after: no goals
tactic: exact M.empty_not_base hB
Theorem: finprod_eq_of_bijective
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g✝ : α → M
a b : α
s t : Set α
f : α → M
g : β → M
e : α → β
he₀ : Bijective e
he₁ : ∀ (x : α), f x = g (e x)
⊢ ∏ᶠ (i : α), f i = ∏ᶠ (j : β), g j
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g✝ : α → M
a b : α
s t : Set α
f : α → M
g : β → M
e : α → β
he₀ : Bijective e
he₁ : ∀ (x : α), f x = g (e x)
⊢ ∏ᶠ (i : α) (_ : i ∈ univ), f i = ∏ᶠ (i : β) (_ : i ∈ univ), g i
tactic: rw [← finprod_mem_univ f, ← finprod_mem_univ g]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g✝ : α → M
a b : α
s t : Set α
f : α → M
g : β → M
e : α → β
he₀ : Bijective e
he₁ : ∀ (x : α), f x = g (e x)
⊢ ∏ᶠ (i : α) (_ : i ∈ univ), f i = ∏ᶠ (i : β) (_ : i ∈ univ), g i
state_after: no goals
tactic: exact finprod_mem_eq_of_bijOn _ (bijective_iff_bijOn_univ.mp he₀) fun x _ => he₁ x
Theorem: MeasureTheory.eLpNorm_indicator_const'
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c✝ : E
f : α → E
hf : AEStronglyMeasurable f μ
s : Set α
c : G
hs : MeasurableSet s
hμs : μ s ≠ 0
hp : p ≠ 0
⊢ eLpNorm (s.indicator fun x => c) p μ = ↑‖c‖₊ * μ s ^ (1 / p.toReal)
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c✝ : E
f : α → E
hf : AEStronglyMeasurable f μ
s : Set α
c : G
hs : MeasurableSet s
hμs : μ s ≠ 0
hp : p ≠ 0
hp_top : p = ⊤
⊢ eLpNorm (s.indicator fun x => c) p μ = ↑‖c‖₊ * μ s ^ (1 / p.toReal)

case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c✝ : E
f : α → E
hf : AEStronglyMeasurable f μ
s : Set α
c : G
hs : MeasurableSet s
hμs : μ s ≠ 0
hp : p ≠ 0
hp_top : ¬p = ⊤
⊢ eLpNorm (s.indicator fun x => c) p μ = ↑‖c‖₊ * μ s ^ (1 / p.toReal)
tactic: by_cases hp_top : p = ∞
Theorem: SimpleGraph.degree_lt_card_verts
File: Mathlib/Combinatorics/SimpleGraph/Finite.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
⊢ G.degree v < Fintype.card V
state_after: no goals
tactic: classical
  apply Finset.card_lt_card
  rw [Finset.ssubset_iff]
  exact ⟨v, by simp, Finset.subset_univ _⟩
Theorem: dist_pi_const
File: Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : PseudoMetricSpace α
π : β → Type u_3
inst✝² : Fintype β
inst✝¹ : (b : β) → PseudoMetricSpace (π b)
inst✝ : Nonempty β
a b : α
⊢ (dist (fun x => a) fun x => b) = dist a b
state_after: no goals
tactic: simpa only [dist_edist] using congr_arg ENNReal.toReal (edist_pi_const a b)
Theorem: CategoryTheory.Functor.leftKanExtensionUniqueOfIso_hom
File: Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean

Proof steps:
state_before: C : Type u_1
C' : Type u_2
H : Type u_3
H' : Type u_4
D : Type u_5
D' : Type u_6
inst✝⁷ : Category.{?u.53378, u_1} C
inst✝⁶ : Category.{?u.53382, u_2} C'
inst✝⁵ : Category.{?u.53386, u_3} H
inst✝⁴ : Category.{?u.53390, u_4} H'
inst✝³ : Category.{?u.53394, u_5} D
inst✝² : Category.{?u.53398, u_6} D'
F' : D ⥤ H
L : C ⥤ D
F : C ⥤ H
α : F ⟶ L ⋙ F'
inst✝¹ : F'.IsLeftKanExtension α
G : C ⥤ H
i : F ≅ G
G' : D ⥤ H
β : G ⟶ L ⋙ G'
inst✝ : G'.IsLeftKanExtension β
⊢ α ≫ whiskerLeft L (F'.descOfIsLeftKanExtension α G' (i.hom ≫ β) ≫ G'.descOfIsLeftKanExtension β F' (i.inv ≫ α)) =
    α ≫ whiskerLeft L (𝟙 F')
state_after: no goals
tactic: simp
state_before: C : Type u_1
C' : Type u_2
H : Type u_3
H' : Type u_4
D : Type u_5
D' : Type u_6
inst✝⁷ : Category.{?u.53378, u_1} C
inst✝⁶ : Category.{?u.53382, u_2} C'
inst✝⁵ : Category.{?u.53386, u_3} H
inst✝⁴ : Category.{?u.53390, u_4} H'
inst✝³ : Category.{?u.53394, u_5} D
inst✝² : Category.{?u.53398, u_6} D'
F' : D ⥤ H
L : C ⥤ D
F : C ⥤ H
α : F ⟶ L ⋙ F'
inst✝¹ : F'.IsLeftKanExtension α
G : C ⥤ H
i : F ≅ G
G' : D ⥤ H
β : G ⟶ L ⋙ G'
inst✝ : G'.IsLeftKanExtension β
⊢ β ≫ whiskerLeft L (G'.descOfIsLeftKanExtension β F' (i.inv ≫ α) ≫ F'.descOfIsLeftKanExtension α G' (i.hom ≫ β)) =
    β ≫ whiskerLeft L (𝟙 G')
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.Bicone.toBinaryBiconeFunctor_obj_snd
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
X Y : C
b : Bicone (pairFunction X Y)
⊢ b.ι WalkingPair.left ≫ b.π WalkingPair.left = 𝟙 X
state_after: no goals
tactic: simp [Bicone.ι_π]
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
X Y : C
b : Bicone (pairFunction X Y)
⊢ b.ι WalkingPair.right ≫ b.π WalkingPair.left = 0
state_after: no goals
tactic: simp [Bicone.ι_π]
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
X Y : C
b : Bicone (pairFunction X Y)
⊢ b.ι WalkingPair.left ≫ b.π WalkingPair.right = 0
state_after: no goals
tactic: simp [Bicone.ι_π]
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
X Y : C
b : Bicone (pairFunction X Y)
⊢ b.ι WalkingPair.right ≫ b.π WalkingPair.right = 𝟙 Y
state_after: no goals
tactic: simp [Bicone.ι_π]
Theorem: Fin.neg_natCast_eq_one
File: Mathlib/Algebra/Group/Fin/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
⊢ -↑n = 1
state_after: no goals
tactic: simp only [natCast_eq_last, neg_last]
Theorem: Set.mem_dite_empty_left
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t✝ t₁ t₂ u : Set α
p : Prop
inst✝ : Decidable p
t : ¬p → Set α
x : α
⊢ (x ∈ if h : p then ∅ else t h) ↔ ∃ (h : ¬p), x ∈ t h
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t✝ t₁ t₂ u : Set α
p : Prop
inst✝ : Decidable p
t : ¬p → Set α
x : α
⊢ (¬p ∧ ∀ (h : ¬p), x ∈ t h) ↔ ∃ (h : ¬p), x ∈ t h
tactic: simp only [mem_dite, mem_empty_iff_false, imp_false]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t✝ t₁ t₂ u : Set α
p : Prop
inst✝ : Decidable p
t : ¬p → Set α
x : α
⊢ (¬p ∧ ∀ (h : ¬p), x ∈ t h) ↔ ∃ (h : ¬p), x ∈ t h
state_after: no goals
tactic: exact ⟨fun h => ⟨h.1, h.2 h.1⟩, fun ⟨h₁, h₂⟩ => ⟨fun h => h₁ h, fun _ => h₂⟩⟩
Theorem: NNReal.young_inequality_real
File: Mathlib/Analysis/MeanInequalities.lean

Proof steps:
state_before: ι : Type u
s : Finset ι
a b : ℝ≥0
p q : ℝ
hpq : p.IsConjExponent q
⊢ a * b ≤ a ^ p / p.toNNReal + b ^ q / q.toNNReal
state_after: no goals
tactic: simpa [Real.coe_toNNReal, hpq.nonneg, hpq.symm.nonneg] using young_inequality a b hpq.toNNReal
Theorem: eq_zero_sub_of_add_eq_zero_right
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
h : a * b = 1
⊢ b = 1 / a
state_after: no goals
tactic: rw [eq_inv_of_mul_eq_one_right h, one_div]
Theorem: Function.support_update_zero
File: Mathlib/Algebra/Group/Support.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
inst✝³ : One M
inst✝² : One N
inst✝¹ : One P
inst✝ : DecidableEq α
f : α → M
x : α
⊢ mulSupport (update f x 1) = mulSupport f \ {x}
state_after: case h
α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
inst✝³ : One M
inst✝² : One N
inst✝¹ : One P
inst✝ : DecidableEq α
f : α → M
x a : α
⊢ a ∈ mulSupport (update f x 1) ↔ a ∈ mulSupport f \ {x}
tactic: ext a
state_before: case h
α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
inst✝³ : One M
inst✝² : One N
inst✝¹ : One P
inst✝ : DecidableEq α
f : α → M
x a : α
⊢ a ∈ mulSupport (update f x 1) ↔ a ∈ mulSupport f \ {x}
state_after: no goals
tactic: rcases eq_or_ne a x with rfl | hne <;> simp [*]
Theorem: Fin.isAddFreimanIso_Iio
File: Mathlib/Combinatorics/Additive/FreimanHom.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
k m n : ℕ
hm : m ≠ 0
hkmn : m * k ≤ n
⊢ IsAddFreimanIso m (Iio ↑k) (Iio k) val
state_after: case zero
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m n : ℕ
hm : m ≠ 0
hkmn : m * 0 ≤ n
⊢ IsAddFreimanIso m (Iio ↑0) (Iio 0) val

case succ
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m n : ℕ
hm : m ≠ 0
k : ℕ
hkmn : m * (k + 1) ≤ n
⊢ IsAddFreimanIso m (Iio ↑(k + 1)) (Iio (k + 1)) val
tactic: obtain _ | k := k
state_before: case succ
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m n : ℕ
hm : m ≠ 0
k : ℕ
hkmn : m * (k + 1) ≤ n
⊢ IsAddFreimanIso m (Iio ↑(k + 1)) (Iio (k + 1)) val
state_after: case succ
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m n : ℕ
hm : m ≠ 0
k : ℕ
hkmn : m * (k + 1) ≤ n
hkmn' : m * k ≤ n
⊢ IsAddFreimanIso m (Iio ↑(k + 1)) (Iio (k + 1)) val
tactic: have hkmn' : m * k ≤ n := (Nat.mul_le_mul_left _ k.le_succ).trans hkmn
state_before: case succ
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m n : ℕ
hm : m ≠ 0
k : ℕ
hkmn : m * (k + 1) ≤ n
hkmn' : m * k ≤ n
⊢ IsAddFreimanIso m (Iio ↑(k + 1)) (Iio (k + 1)) val
state_after: case h.e'_6.h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m n : ℕ
hm : m ≠ 0
k : ℕ
hkmn : m * (k + 1) ≤ n
hkmn' : m * k ≤ n
x : Fin (n + 1)
⊢ x ∈ Iio ↑(k + 1) ↔ x ∈ Iic ↑k

case h.e'_7.h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m n : ℕ
hm : m ≠ 0
k : ℕ
hkmn : m * (k + 1) ≤ n
hkmn' : m * k ≤ n
x : ℕ
⊢ x ∈ Iio (k + 1) ↔ x ∈ Iic k
tactic: convert isAddFreimanIso_Iic hm hkmn' using 1 <;> ext x
Theorem: conj_pow
File: Mathlib/Algebra/Group/Conj.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Group α
i : ℕ
a b : α
⊢ (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹
state_after: case zero
α : Type u
β : Type v
inst✝ : Group α
a b : α
⊢ (a * b * a⁻¹) ^ 0 = a * b ^ 0 * a⁻¹

case succ
α : Type u
β : Type v
inst✝ : Group α
a b : α
i : ℕ
hi : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹
⊢ (a * b * a⁻¹) ^ (i + 1) = a * b ^ (i + 1) * a⁻¹
tactic: induction' i with i hi
Theorem: AddChar.mulShift_zero
File: Mathlib/Algebra/Group/AddChar.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
⊢ ψ.mulShift 0 = 1
state_after: case h
R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
x✝ : R
⊢ (ψ.mulShift 0) x✝ = 1 x✝
tactic: ext
state_before: case h
R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
x✝ : R
⊢ (ψ.mulShift 0) x✝ = 1 x✝
state_after: no goals
tactic: rw [mulShift_apply, zero_mul, map_zero_eq_one, one_apply]
Theorem: pointed_innerDualCone
File: Mathlib/Analysis/Convex/Cone/InnerDual.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
x : H
x✝ : x ∈ s
⊢ 0 ≤ ⟪x, 0⟫_ℝ
state_after: no goals
tactic: rw [inner_zero_right]
Theorem: CategoryTheory.Idempotents.Karoubi.decompId_i_f
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.37256, u_1} C
P : Karoubi C
⊢ P.p = P.p ≫ P.p ≫ { X := P.X, p := 𝟙 P.X, idem := ⋯ }.p
state_after: no goals
tactic: erw [coe_p, comp_id, P.idem]
Theorem: Int.norm_cast_rat
File: Mathlib/Analysis/Normed/Group/Rat.lean

Proof steps:
state_before: m : ℤ
⊢ ‖↑m‖ = ‖m‖
state_after: m : ℤ
⊢ ‖↑↑m‖ = ‖↑m‖
tactic: rw [← Rat.norm_cast_real, ← Int.norm_cast_real]
state_before: m : ℤ
⊢ ‖↑↑m‖ = ‖↑m‖
state_after: no goals
tactic: congr 1
Theorem: inv_mul_cancel_right₀
File: Mathlib/Algebra/GroupWithZero/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a✝ b c g h✝ x : G₀
h : b ≠ 0
a : G₀
⊢ a * (b⁻¹ * b) = a
state_after: no goals
tactic: simp [h]
Theorem: Nat.mem_divisorsAntidiagonal
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n : ℕ
x : ℕ × ℕ
⊢ x ∈ n.divisorsAntidiagonal ↔ x.1 * x.2 = n ∧ n ≠ 0
state_after: n : ℕ
x : ℕ × ℕ
⊢ ((1 ≤ x.1 ∧ x.1 < n + 1) ∧ 1 ≤ x.2 ∧ x.2 < n + 1) ∧ x.1 * x.2 = n ↔ x.1 * x.2 = n ∧ ¬n = 0
tactic: simp only [divisorsAntidiagonal, Finset.mem_Ico, Ne, Finset.mem_filter, Finset.mem_product]
state_before: n : ℕ
x : ℕ × ℕ
⊢ ((1 ≤ x.1 ∧ x.1 < n + 1) ∧ 1 ≤ x.2 ∧ x.2 < n + 1) ∧ x.1 * x.2 = n ↔ x.1 * x.2 = n ∧ ¬n = 0
state_after: n : ℕ
x : ℕ × ℕ
⊢ x.1 * x.2 = n ∧ (1 ≤ x.1 ∧ x.1 < n + 1) ∧ 1 ≤ x.2 ∧ x.2 < n + 1 ↔ x.1 * x.2 = n ∧ ¬n = 0
tactic: rw [and_comm]
state_before: n : ℕ
x : ℕ × ℕ
⊢ x.1 * x.2 = n ∧ (1 ≤ x.1 ∧ x.1 < n + 1) ∧ 1 ≤ x.2 ∧ x.2 < n + 1 ↔ x.1 * x.2 = n ∧ ¬n = 0
state_after: case h
n : ℕ
x : ℕ × ℕ
⊢ x.1 * x.2 = n → ((1 ≤ x.1 ∧ x.1 < n + 1) ∧ 1 ≤ x.2 ∧ x.2 < n + 1 ↔ ¬n = 0)
tactic: apply and_congr_right
state_before: case h
n : ℕ
x : ℕ × ℕ
⊢ x.1 * x.2 = n → ((1 ≤ x.1 ∧ x.1 < n + 1) ∧ 1 ≤ x.2 ∧ x.2 < n + 1 ↔ ¬n = 0)
state_after: case h
x : ℕ × ℕ
⊢ (1 ≤ x.1 ∧ x.1 < x.1 * x.2 + 1) ∧ 1 ≤ x.2 ∧ x.2 < x.1 * x.2 + 1 ↔ ¬x.1 * x.2 = 0
tactic: rintro rfl
state_before: case h
x : ℕ × ℕ
⊢ (1 ≤ x.1 ∧ x.1 < x.1 * x.2 + 1) ∧ 1 ≤ x.2 ∧ x.2 < x.1 * x.2 + 1 ↔ ¬x.1 * x.2 = 0
state_after: case h.mp
x : ℕ × ℕ
h : (1 ≤ x.1 ∧ x.1 < x.1 * x.2 + 1) ∧ 1 ≤ x.2 ∧ x.2 < x.1 * x.2 + 1
⊢ ¬x.1 * x.2 = 0

case h.mpr
x : ℕ × ℕ
h : ¬x.1 * x.2 = 0
⊢ (1 ≤ x.1 ∧ x.1 < x.1 * x.2 + 1) ∧ 1 ≤ x.2 ∧ x.2 < x.1 * x.2 + 1
tactic: constructor <;> intro h
Theorem: HomologicalComplex.unop_X
File: Mathlib/Algebra/Homology/Opposite.lean

Proof steps:
state_before: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.20862, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : HomologicalComplex Vᵒᵖ c
i j : ι
hij : ¬c.symm.Rel i j
⊢ (fun i j => (X.d j i).unop) i j = 0
state_after: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.20862, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : HomologicalComplex Vᵒᵖ c
i j : ι
hij : ¬c.symm.Rel i j
⊢ (X.d j i).unop = 0
tactic: simp only
state_before: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.20862, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : HomologicalComplex Vᵒᵖ c
i j : ι
hij : ¬c.symm.Rel i j
⊢ (X.d j i).unop = 0
state_after: no goals
tactic: rw [X.shape j i hij, unop_zero]
state_before: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.20862, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : HomologicalComplex Vᵒᵖ c
x✝⁴ x✝³ x✝² : ι
x✝¹ : c.symm.Rel x✝⁴ x✝³
x✝ : c.symm.Rel x✝³ x✝²
⊢ (fun i j => (X.d j i).unop) x✝⁴ x✝³ ≫ (fun i j => (X.d j i).unop) x✝³ x✝² = 0
state_after: no goals
tactic: rw [← unop_comp, X.d_comp_d, unop_zero]
Theorem: WittVector.mapFun.surjective
File: Mathlib/RingTheory/WittVector/Basic.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
f : α → β
hf : Surjective f
x : 𝕎 β
⊢ mapFun f (mk p fun n => Classical.choose ⋯) = x
state_after: case h
p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
f : α → β
hf : Surjective f
x : 𝕎 β
n : ℕ
⊢ (mapFun f (mk p fun n => Classical.choose ⋯)).coeff n = x.coeff n
tactic: ext n
state_before: case h
p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
f : α → β
hf : Surjective f
x : 𝕎 β
n : ℕ
⊢ (mapFun f (mk p fun n => Classical.choose ⋯)).coeff n = x.coeff n
state_after: no goals
tactic: simp only [mapFun, coeff_mk, comp_apply, Classical.choose_spec (hf (x.coeff n))]
Theorem: List.ofFn_eq_ofFnTR
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

Proof steps:
state_before: ⊢ @ofFn = @ofFnTR
state_after: case h.h.h
α : Type u_1
n : Nat
f : Fin n → α
⊢ ofFn f = ofFnTR f
tactic: funext α n f
state_before: case h.h.h
α : Type u_1
n : Nat
f : Fin n → α
⊢ ofFn f = ofFnTR f
state_after: case h.h.h
α : Type u_1
n : Nat
f : Fin n → α
⊢ ofFn f = ofFnTR.go f n ⋯ []
tactic: simp [ofFnTR]
state_before: α : Type u_1
n : Nat
f : Fin n → α
i j : Nat
h : i + j = n
h' : j ≤ n
⊢ ofFnTR.go f j h' (ofFn.go f i j h) = ofFn f
state_after: α : Type u_1
n : Nat
f : Fin n → α
i j : Nat
h : i + j = n
h' : j ≤ n
⊢ (match j, h', ofFn.go f i j h with
    | 0, x, acc => acc
    | i.succ, h, acc => ofFnTR.go f i ⋯ (f ⟨i, h⟩ :: acc)) =
    ofFn f
tactic: unfold ofFnTR.go
state_before: α : Type u_1
n : Nat
f : Fin n → α
i j : Nat
h : i + j = n
h' : j ≤ n
⊢ (match j, h', ofFn.go f i j h with
    | 0, x, acc => acc
    | i.succ, h, acc => ofFnTR.go f i ⋯ (f ⟨i, h⟩ :: acc)) =
    ofFn f
state_after: case h_1
α : Type u_1
n : Nat
f : Fin n → α
i x✝³ : Nat
x✝² : x✝³ ≤ n
x✝¹ : List α
x✝ : 0 ≤ n
h : i + 0 = n
⊢ ofFn.go f i 0 h = ofFn f

case h_2
α : Type u_1
n : Nat
f : Fin n → α
i x✝² : Nat
x✝¹ : x✝² ≤ n
x✝ : List α
i✝ : Nat
h✝ : i✝ + 1 ≤ n
h : i + i✝.succ = n
⊢ ofFnTR.go f i✝ ⋯ (f ⟨i✝, h✝⟩ :: ofFn.go f i i✝.succ h) = ofFn f
tactic: split
state_before: case h.h.h
α : Type u_1
n : Nat
f : Fin n → α
⊢ ofFn f = ofFnTR.go f n ⋯ []
state_after: no goals
tactic: exact (go 0 n (Nat.zero_add _) (Nat.le_refl _)).symm
Theorem: Traversable.traverse_map
File: Mathlib/Control/Traversable/Lemmas.lean

Proof steps:
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h : β → G γ
f✝ : β → γ
x✝ : t β
f : β → F γ
g : α → β
x : t α
⊢ traverse f (g <$> x) = traverse (f ∘ g) x
state_after: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h : β → G γ
f✝ : β → γ
x✝ : t β
f : β → F γ
g : α → β
x : t α
⊢ traverse f (traverse (pure ∘ g) x) = traverse (f ∘ g) x
tactic: rw [@map_eq_traverse_id t _ _ _ _ g]
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h : β → G γ
f✝ : β → γ
x✝ : t β
f : β → F γ
g : α → β
x : t α
⊢ traverse f (traverse (pure ∘ g) x) = traverse (f ∘ g) x
state_after: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h : β → G γ
f✝ : β → γ
x✝ : t β
f : β → F γ
g : α → β
x : t α
⊢ traverse (Comp.mk ∘ map f ∘ pure ∘ g) x = traverse (f ∘ g) x
tactic: refine (comp_traverse (G := Id) f (pure ∘ g) x).symm.trans ?_
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h : β → G γ
f✝ : β → γ
x✝ : t β
f : β → F γ
g : α → β
x : t α
⊢ traverse (Comp.mk ∘ map f ∘ pure ∘ g) x = traverse (f ∘ g) x
state_after: case h.e_4.h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h : β → G γ
f✝ : β → γ
x✝ : t β
f : β → F γ
g : α → β
x : t α
⊢ Comp.instApplicativeComp = inst✝³
tactic: congr
state_before: case h.e_4.h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h : β → G γ
f✝ : β → γ
x✝ : t β
f : β → F γ
g : α → β
x : t α
⊢ Comp.instApplicativeComp = inst✝³
state_after: no goals
tactic: apply Comp.applicative_id_comp