ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Set.not_mem_uIoc
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ a ∉ Ι b c ↔ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ ¬(¬a ≤ b ∧ a ≤ c ∨ ¬a ≤ c ∧ a ≤ b) ↔ a ≤ b ∧ a ≤ c ∨ ¬a ≤ c ∧ ¬a ≤ b
tactic: simp only [uIoc_eq_union, mem_union, mem_Ioc, not_lt, ← not_le]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ ¬(¬a ≤ b ∧ a ≤ c ∨ ¬a ≤ c ∧ a ≤ b) ↔ a ≤ b ∧ a ≤ c ∨ ¬a ≤ c ∧ ¬a ≤ b
state_after: no goals
tactic: tauto
Theorem: MeasurableSpace.measurableSet_sInf
File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
ms : Set (MeasurableSpace α)
s : Set α
⊢ s ∈ ⋂₀ ((fun m => {t | MeasurableSet t}) '' ms) ↔ ∀ m ∈ ms, MeasurableSet s
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.coprodComparisonNatIso_hom
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

Proof steps:
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
X Y : C
D : Type u₂
inst✝⁷ : Category.{w, u₂} D
F : C ⥤ D
A✝ A' B B' : C
inst✝⁶ : HasBinaryCoproduct A✝ B
inst✝⁵ : HasBinaryCoproduct A' B'
inst✝⁴ : HasBinaryCoproduct (F.obj A✝) (F.obj B)
inst✝³ : HasBinaryCoproduct (F.obj A') (F.obj B')
inst✝² : HasBinaryCoproducts C
inst✝¹ : HasBinaryCoproducts D
A : C
inst✝ : ∀ (B : C), IsIso (coprodComparison F A B)
⊢ F ⋙ coprod.functor.obj (F.obj A) ≅ coprod.functor.obj A ⋙ F
state_after: C : Type u
inst✝⁸ : Category.{v, u} C
X Y : C
D : Type u₂
inst✝⁷ : Category.{w, u₂} D
F : C ⥤ D
A✝ A' B B' : C
inst✝⁶ : HasBinaryCoproduct A✝ B
inst✝⁵ : HasBinaryCoproduct A' B'
inst✝⁴ : HasBinaryCoproduct (F.obj A✝) (F.obj B)
inst✝³ : HasBinaryCoproduct (F.obj A') (F.obj B')
inst✝² : HasBinaryCoproducts C
inst✝¹ : HasBinaryCoproducts D
A : C
inst✝ : ∀ (B : C), IsIso (coprodComparison F A B)
⊢ IsIso { app := fun B => coprodComparison F A B, naturality := ⋯ }
tactic: refine { @asIso _ _ _ _ _ (?_) with hom := coprodComparisonNatTrans F A }
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
X Y : C
D : Type u₂
inst✝⁷ : Category.{w, u₂} D
F : C ⥤ D
A✝ A' B B' : C
inst✝⁶ : HasBinaryCoproduct A✝ B
inst✝⁵ : HasBinaryCoproduct A' B'
inst✝⁴ : HasBinaryCoproduct (F.obj A✝) (F.obj B)
inst✝³ : HasBinaryCoproduct (F.obj A') (F.obj B')
inst✝² : HasBinaryCoproducts C
inst✝¹ : HasBinaryCoproducts D
A : C
inst✝ : ∀ (B : C), IsIso (coprodComparison F A B)
⊢ IsIso { app := fun B => coprodComparison F A B, naturality := ⋯ }
state_after: no goals
tactic: apply NatIso.isIso_of_isIso_app
Theorem: List.chain_range_succ
File: Mathlib/Data/List/Range.lean

Proof steps:
state_before: α : Type u
r : ℕ → ℕ → Prop
n a : ℕ
⊢ Chain r a (range n.succ) ↔ r a 0 ∧ ∀ m < n, r m m.succ
state_after: α : Type u
r : ℕ → ℕ → Prop
n a : ℕ
⊢ r a 0 → (Chain r 0 (map succ (range n)) ↔ Chain' r (0 :: map succ (range n)))
tactic: rw [range_succ_eq_map, chain_cons, and_congr_right_iff, ← chain'_range_succ, range_succ_eq_map]
state_before: α : Type u
r : ℕ → ℕ → Prop
n a : ℕ
⊢ r a 0 → (Chain r 0 (map succ (range n)) ↔ Chain' r (0 :: map succ (range n)))
state_after: no goals
tactic: exact fun _ => Iff.rfl
Theorem: Finset.sym2_eq_image
File: Mathlib/Data/Finset/Sym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
⊢ s.sym2 = image Sym2.mk (s ×ˢ s)
state_after: case a
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
z : Sym2 α
⊢ z ∈ s.sym2 ↔ z ∈ image Sym2.mk (s ×ˢ s)
tactic: ext z
state_before: case a
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
z : Sym2 α
⊢ z ∈ s.sym2 ↔ z ∈ image Sym2.mk (s ×ˢ s)
state_after: case a
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
z : Sym2 α
x y : α
⊢ s(x, y) ∈ s.sym2 ↔ s(x, y) ∈ image Sym2.mk (s ×ˢ s)
tactic: refine z.ind fun x y ↦ ?_
state_before: case a
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
z : Sym2 α
x y : α
⊢ s(x, y) ∈ s.sym2 ↔ s(x, y) ∈ image Sym2.mk (s ×ˢ s)
state_after: case a
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
z : Sym2 α
x y : α
⊢ x ∈ s ∧ y ∈ s ↔ ∃ a ∈ s ×ˢ s, Sym2.mk a = s(x, y)
tactic: rw [mk_mem_sym2_iff, mem_image]
state_before: case a
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
z : Sym2 α
x y : α
⊢ x ∈ s ∧ y ∈ s ↔ ∃ a ∈ s ×ˢ s, Sym2.mk a = s(x, y)
state_after: case a.mp
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
z : Sym2 α
x y : α
⊢ x ∈ s ∧ y ∈ s → ∃ a ∈ s ×ˢ s, Sym2.mk a = s(x, y)

case a.mpr
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
z : Sym2 α
x y : α
⊢ (∃ a ∈ s ×ˢ s, Sym2.mk a = s(x, y)) → x ∈ s ∧ y ∈ s
tactic: constructor
Theorem: CliffordAlgebra.toEven_ι
File: Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ ↑((toEven Q) ((ι Q) m)) = e0 Q * (v Q) m
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ ↑((LinearMap.codRestrict (evenOdd (Q' Q) 0) (LinearMap.mulLeft R (e0 Q) ∘ₗ v Q) ⋯) m) = e0 Q * (v Q) m
tactic: rw [toEven, CliffordAlgebra.lift_ι_apply]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ ↑((LinearMap.codRestrict (evenOdd (Q' Q) 0) (LinearMap.mulLeft R (e0 Q) ∘ₗ v Q) ⋯) m) = e0 Q * (v Q) m
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ (LinearMap.mulLeft R (e0 Q) ∘ₗ v Q) m = e0 Q * (v Q) m
tactic: erw [LinearMap.codRestrict_apply]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ (LinearMap.mulLeft R (e0 Q) ∘ₗ v Q) m = e0 Q * (v Q) m
state_after: no goals
tactic: rw [LinearMap.coe_comp, Function.comp_apply, LinearMap.mulLeft_apply]
Theorem: Polynomial.cyclotomic.eval_apply
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
q : R
n : ℕ
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
⊢ eval (f q) (cyclotomic n S) = f (eval q (cyclotomic n R))
state_after: no goals
tactic: rw [← map_cyclotomic n f, eval_map, eval₂_at_apply]
Theorem: Polynomial.leadingCoeff_cubic
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
ha : a ≠ 0
⊢ (C a * X ^ 3 + C b * X ^ 2 + C c * X + C d).leadingCoeff = a
state_after: no goals
tactic: rw [add_assoc, add_assoc, ← add_assoc (C b * X ^ 2), add_comm,
    leadingCoeff_add_of_degree_lt <| degree_quadratic_lt_degree_C_mul_X_cb ha,
    leadingCoeff_C_mul_X_pow]
Theorem: MeasureTheory.integral_eq_zero_of_add_right_eq_neg
File: Mathlib/MeasureTheory/Group/Integral.lean

Proof steps:
state_before: 𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f : G → E
g : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : μ.IsMulRightInvariant
hf' : ∀ (x : G), f (x * g) = -f x
⊢ ∫ (x : G), f x ∂μ = 0
state_after: no goals
tactic: simp_rw [← self_eq_neg ℝ E, ← integral_neg, ← hf', integral_mul_right_eq_self]
Theorem: smul_eq_zero_iff_left
File: Mathlib/Algebra/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
k : Type u_3
S : Type u_4
M : Type u_5
M₂ : Type u_6
M₃ : Type u_7
ι : Type u_8
inst✝³ : Zero R
inst✝² : Zero M
inst✝¹ : SMulWithZero R M
inst✝ : NoZeroSMulDivisors R M
c : R
x : M
hx : x ≠ 0
⊢ c • x = 0 ↔ c = 0
state_after: no goals
tactic: simp [hx]
Theorem: CategoryTheory.PreGaloisCategory.evaluation_aut_injective_of_isConnected
File: Mathlib/CategoryTheory/Galois/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Function.Injective fun f => F.map f.hom a
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Function.Injective ((fun f => F.map f a) ∘ fun f => f.hom)
tactic: show Function.Injective ((fun f : A ⟶ A ↦ F.map f a) ∘ (fun f : Aut A ↦ f.hom))
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Function.Injective ((fun f => F.map f a) ∘ fun f => f.hom)
state_after: case hg
C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Function.Injective fun f => F.map f a

case hf
C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Function.Injective fun f => f.hom
tactic: apply Function.Injective.comp
Theorem: LaurentSeries.powerSeriesPart_eq_zero
File: Mathlib/RingTheory/LaurentSeries.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
x : LaurentSeries R
⊢ x.powerSeriesPart = 0 ↔ x = 0
state_after: case mp
R : Type u_1
inst✝ : Semiring R
x : LaurentSeries R
⊢ x.powerSeriesPart = 0 → x = 0

case mpr
R : Type u_1
inst✝ : Semiring R
x : LaurentSeries R
⊢ x = 0 → x.powerSeriesPart = 0
tactic: constructor
Theorem: FirstOrder.Language.BoundedFormula.mapTermRelEquiv_symm_apply
File: Mathlib/ModelTheory/Syntax.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ : ℕ
ft : (n : ℕ) → L.Term (α ⊕ Fin n) ≃ L'.Term (β ⊕ Fin n)
fr : (n : ℕ) → L.Relations n ≃ L'.Relations n
n : ℕ
φ : L.BoundedFormula α n
⊢ mapTermRel (fun n => ⇑(ft n).symm) (fun n => ⇑(fr n).symm) (fun x => id)
      (mapTermRel (fun n => ⇑(ft n)) (fun n => ⇑(fr n)) (fun x => id) φ) =
    φ
state_after: no goals
tactic: simp
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ : ℕ
ft : (n : ℕ) → L.Term (α ⊕ Fin n) ≃ L'.Term (β ⊕ Fin n)
fr : (n : ℕ) → L.Relations n ≃ L'.Relations n
n : ℕ
φ : L'.BoundedFormula β n
⊢ mapTermRel (fun n => ⇑(ft n)) (fun n => ⇑(fr n)) (fun x => id)
      (mapTermRel (fun n => ⇑(ft n).symm) (fun n => ⇑(fr n).symm) (fun x => id) φ) =
    φ
state_after: no goals
tactic: simp
Theorem: SetTheory.PGame.neg_fuzzy_iff
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x y : PGame
⊢ -x ‖ y ↔ x ‖ -y
state_after: no goals
tactic: rw [← neg_neg y, neg_fuzzy_neg_iff, neg_neg]
Theorem: ENNReal.tsum_const_eq
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
c : ℝ≥0∞
⊢ ∑' (x : α), c = c * count univ
state_after: no goals
tactic: rw [← lintegral_count, lintegral_const]
Theorem: Finset.max_of_mem
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 α
a : α
h : a ∈ s
⊢ ∃ b, s.max = ↑b
state_after: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
a : α
h✝ : a ∈ s
b : α
h : s.sup WithBot.some = ↑b
right✝ : a ≤ b
⊢ ∃ b, s.max = ↑b
tactic: obtain ⟨b, h, _⟩ := le_sup (α := WithBot α) h _ rfl
state_before: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
a : α
h✝ : a ∈ s
b : α
h : s.sup WithBot.some = ↑b
right✝ : a ≤ b
⊢ ∃ b, s.max = ↑b
state_after: no goals
tactic: exact ⟨b, h⟩
Theorem: CliffordAlgebra.changeFormAux_changeFormAux
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

Proof steps:
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
B : BilinForm R M
v : M
x : CliffordAlgebra Q
⊢ ((changeFormAux Q B) v) (((changeFormAux Q B) v) x) = (Q v - (B v) v) • x
state_after: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
B : BilinForm R M
v : M
x : CliffordAlgebra Q
⊢ (ι Q) v * ((ι Q) v * x - (contractLeft (B v)) x) - (contractLeft (B v)) ((ι Q) v * x - (contractLeft (B v)) x) =
    (Q v - (B v) v) • x
tactic: simp only [changeFormAux_apply_apply]
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
B : BilinForm R M
v : M
x : CliffordAlgebra Q
⊢ (ι Q) v * ((ι Q) v * x - (contractLeft (B v)) x) - (contractLeft (B v)) ((ι Q) v * x - (contractLeft (B v)) x) =
    (Q v - (B v) v) • x
state_after: no goals
tactic: rw [mul_sub, ← mul_assoc, ι_sq_scalar, map_sub, contractLeft_ι_mul, ← sub_add, sub_sub_sub_comm,
    ← Algebra.smul_def, sub_self, sub_zero, contractLeft_contractLeft, add_zero, sub_smul]
Theorem: AlgEquiv.ofLinearEquiv_toLinearEquiv
File: Mathlib/Algebra/Algebra/Equiv.lean

Proof steps:
state_before: R : Type uR
A₁ : Type uA₁
A₂ : Type uA₂
A₃ : Type uA₃
A₁' : Type uA₁'
A₂' : Type uA₂'
A₃' : Type uA₃'
inst✝¹² : CommSemiring R
inst✝¹¹ : Semiring A₁
inst✝¹⁰ : Semiring A₂
inst✝⁹ : Semiring A₃
inst✝⁸ : Semiring A₁'
inst✝⁷ : Semiring A₂'
inst✝⁶ : Semiring A₃'
inst✝⁵ : Algebra R A₁
inst✝⁴ : Algebra R A₂
inst✝³ : Algebra R A₃
inst✝² : Algebra R A₁'
inst✝¹ : Algebra R A₂'
inst✝ : Algebra R A₃'
e : A₁ ≃ₐ[R] A₂
l : A₁ ≃ₗ[R] A₂
map_one✝ : l 1 = 1
map_mul✝ : ∀ (x y : A₁), l (x * y) = l x * l y
map_mul : e.toLinearEquiv 1 = 1
map_one : ∀ (x y : A₁), e.toLinearEquiv (x * y) = e.toLinearEquiv x * e.toLinearEquiv y
⊢ ofLinearEquiv e.toLinearEquiv map_mul map_one = e
state_after: case h
R : Type uR
A₁ : Type uA₁
A₂ : Type uA₂
A₃ : Type uA₃
A₁' : Type uA₁'
A₂' : Type uA₂'
A₃' : Type uA₃'
inst✝¹² : CommSemiring R
inst✝¹¹ : Semiring A₁
inst✝¹⁰ : Semiring A₂
inst✝⁹ : Semiring A₃
inst✝⁸ : Semiring A₁'
inst✝⁷ : Semiring A₂'
inst✝⁶ : Semiring A₃'
inst✝⁵ : Algebra R A₁
inst✝⁴ : Algebra R A₂
inst✝³ : Algebra R A₃
inst✝² : Algebra R A₁'
inst✝¹ : Algebra R A₂'
inst✝ : Algebra R A₃'
e : A₁ ≃ₐ[R] A₂
l : A₁ ≃ₗ[R] A₂
map_one✝ : l 1 = 1
map_mul✝ : ∀ (x y : A₁), l (x * y) = l x * l y
map_mul : e.toLinearEquiv 1 = 1
map_one : ∀ (x y : A₁), e.toLinearEquiv (x * y) = e.toLinearEquiv x * e.toLinearEquiv y
a✝ : A₁
⊢ (ofLinearEquiv e.toLinearEquiv map_mul map_one) a✝ = e a✝
tactic: ext
state_before: case h
R : Type uR
A₁ : Type uA₁
A₂ : Type uA₂
A₃ : Type uA₃
A₁' : Type uA₁'
A₂' : Type uA₂'
A₃' : Type uA₃'
inst✝¹² : CommSemiring R
inst✝¹¹ : Semiring A₁
inst✝¹⁰ : Semiring A₂
inst✝⁹ : Semiring A₃
inst✝⁸ : Semiring A₁'
inst✝⁷ : Semiring A₂'
inst✝⁶ : Semiring A₃'
inst✝⁵ : Algebra R A₁
inst✝⁴ : Algebra R A₂
inst✝³ : Algebra R A₃
inst✝² : Algebra R A₁'
inst✝¹ : Algebra R A₂'
inst✝ : Algebra R A₃'
e : A₁ ≃ₐ[R] A₂
l : A₁ ≃ₗ[R] A₂
map_one✝ : l 1 = 1
map_mul✝ : ∀ (x y : A₁), l (x * y) = l x * l y
map_mul : e.toLinearEquiv 1 = 1
map_one : ∀ (x y : A₁), e.toLinearEquiv (x * y) = e.toLinearEquiv x * e.toLinearEquiv y
a✝ : A₁
⊢ (ofLinearEquiv e.toLinearEquiv map_mul map_one) a✝ = e a✝
state_after: no goals
tactic: rfl
Theorem: FinVec.forall_iff
File: Mathlib/Data/Fin/Tuple/Reflection.lean

Proof steps:
state_before: m n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
P : (Fin 0 → α) → Prop
⊢ Forall P ↔ ∀ (x : Fin 0 → α), P x
state_after: m n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
P : (Fin 0 → α) → Prop
⊢ P ![] ↔ P finZeroElim
tactic: simp only [Forall, Fin.forall_fin_zero_pi]
state_before: m n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
P : (Fin 0 → α) → Prop
⊢ P ![] ↔ P finZeroElim
state_after: no goals
tactic: rfl
state_before: m n✝ : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
P : (Fin n.succ → α) → Prop
⊢ Forall P ↔ ∀ (x : Fin n.succ → α), P x
state_after: no goals
tactic: simp only [Forall, forall_iff, Fin.forall_fin_succ_pi, Matrix.vecCons]
Theorem: MeasureTheory.hasFiniteIntegral_iff_norm
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 : α → β
⊢ HasFiniteIntegral f μ ↔ ∫⁻ (a : α), ENNReal.ofReal ‖f a‖ ∂μ < ⊤
state_after: no goals
tactic: simp only [HasFiniteIntegral, ofReal_norm_eq_coe_nnnorm]
Theorem: ProbabilityTheory.Kernel.fst_swapRight
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : Kernel α (β × γ)
⊢ κ.swapRight.fst = κ.snd
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : Kernel α (β × γ)
a : α
s : Set γ
hs : MeasurableSet s
⊢ (κ.swapRight.fst a) s = (κ.snd a) s
tactic: ext a s hs
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : Kernel α (β × γ)
a : α
s : Set γ
hs : MeasurableSet s
⊢ (κ.swapRight.fst a) s = (κ.snd a) s
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : Kernel α (β × γ)
a : α
s : Set γ
hs : MeasurableSet s
⊢ (κ a) {p | p.swap ∈ {p | p.1 ∈ s}} = (κ a) {p | p.2 ∈ s}

case h.h.hs
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : Kernel α (β × γ)
a : α
s : Set γ
hs : MeasurableSet s
⊢ MeasurableSet {p | p.1 ∈ s}
tactic: rw [fst_apply' _ _ hs, swapRight_apply', snd_apply' _ _ hs]
Theorem: Algebra.rank_le_of_injective_injective
File: Mathlib/LinearAlgebra/Dimension/Basic.lean

Proof steps:
state_before: R✝ : Type u
R'✝ : Type u'
M M₁ : Type v
M' : Type v'
inst✝¹⁸ : Ring R✝
inst✝¹⁷ : Ring R'✝
inst✝¹⁶ : AddCommGroup M
inst✝¹⁵ : AddCommGroup M'
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R✝ M
inst✝¹² : Module R✝ M'
inst✝¹¹ : Module R✝ M₁
inst✝¹⁰ : Module R'✝ M'
inst✝⁹ : Module R'✝ M₁
R : Type w
S : Type v
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
R' : Type w'
S'✝ : Type v'
inst✝⁵ : CommRing R'
inst✝⁴ : Ring S'✝
inst✝³ : Algebra R' S'✝
S' : Type v
inst✝² : CommRing R'
inst✝¹ : Ring S'
inst✝ : Algebra R' S'
i : R' →+* R
j : S →+* S'
hi : Injective ⇑i
hj : Injective ⇑j
hc : (j.comp (algebraMap R S)).comp i = algebraMap R' S'
⊢ Module.rank R S ≤ Module.rank R' S'
state_after: no goals
tactic: simpa only [lift_id] using lift_rank_le_of_injective_injective i j hi hj hc
Theorem: Projectivization.map_id
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
L : Type u_3
W : Type u_4
inst✝² : DivisionRing L
inst✝¹ : AddCommGroup W
inst✝ : Module L W
⊢ map LinearMap.id ⋯ = id
state_after: case h.mk
K : Type u_1
V : Type u_2
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
L : Type u_3
W : Type u_4
inst✝² : DivisionRing L
inst✝¹ : AddCommGroup W
inst✝ : Module L W
x✝ : ℙ K V
v : { v // v ≠ 0 }
⊢ map LinearMap.id ⋯ (Quot.mk Setoid.r v) = id (Quot.mk Setoid.r v)
tactic: ext ⟨v⟩
state_before: case h.mk
K : Type u_1
V : Type u_2
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
L : Type u_3
W : Type u_4
inst✝² : DivisionRing L
inst✝¹ : AddCommGroup W
inst✝ : Module L W
x✝ : ℙ K V
v : { v // v ≠ 0 }
⊢ map LinearMap.id ⋯ (Quot.mk Setoid.r v) = id (Quot.mk Setoid.r v)
state_after: no goals
tactic: rfl
Theorem: UV.mem_compression
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b : α
inst✝ : DecidableEq α
⊢ a ∈ 𝓒 u v s ↔ a ∈ s ∧ compress u v a ∈ s ∨ a ∉ s ∧ ∃ b ∈ s, compress u v b = a
state_after: no goals
tactic: simp_rw [compression, mem_union, mem_filter, mem_image, and_comm]
Theorem: lowerSemicontinuousAt_iSup
File: Mathlib/Topology/Semicontinuous.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
β : Type u_2
inst✝² : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Sort u_3
δ : Type u_4
δ' : Type u_5
inst✝¹ : CompleteLinearOrder δ
inst✝ : ConditionallyCompleteLinearOrder δ'
f : ι → α → δ
h : ∀ (i : ι), LowerSemicontinuousAt (f i) x
⊢ ∀ᶠ (y : α) in 𝓝 x, BddAbove (range fun i => f i y)
state_after: no goals
tactic: simp
Theorem: List.getLast?_append
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ l₁ l₂ : List α
x : α
h : x ∈ l₂.getLast?
⊢ x ∈ (l₁ ++ l₂).getLast?
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂ l₁ : List α
x : α
h : x ∈ [].getLast?
⊢ x ∈ (l₁ ++ []).getLast?

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂ l₁ : List α
x head✝ : α
tail✝ : List α
h : x ∈ (head✝ :: tail✝).getLast?
⊢ x ∈ (l₁ ++ head✝ :: tail✝).getLast?
tactic: cases l₂
Theorem: LieSubmodule.lieSpan_eq_bot_iff
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
⊢ lieSpan R L s = ⊥ ↔ ∀ m ∈ s, m = 0
state_after: no goals
tactic: rw [_root_.eq_bot_iff, lieSpan_le, bot_coe, subset_singleton_iff]
Theorem: add_eq_of_eq_sub
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✝ : Group G
a b c d : G
n : ℤ
h : a = c / b
⊢ a * b = c
state_after: no goals
tactic: simp [h]