ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LinearPMap.inverse_closure
File: Mathlib/Topology/Algebra/Module/LinearPMap.lean

Proof steps:
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
hf' : f.IsClosable
hcf : LinearMap.ker f.closure.toFun = ⊥
⊢ f.inverse.closure = f.closure.inverse
state_after: case h
R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
hf' : f.IsClosable
hcf : LinearMap.ker f.closure.toFun = ⊥
⊢ f.inverse.closure.graph = f.closure.inverse.graph
tactic: apply eq_of_eq_graph
state_before: case h
R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
hf' : f.IsClosable
hcf : LinearMap.ker f.closure.toFun = ⊥
⊢ f.inverse.closure.graph = f.closure.inverse.graph
state_after: no goals
tactic: rw [closure_inverse_graph hf hf' hcf,
    ((inverse_isClosable_iff hf hf').mpr hcf).graph_closure_eq_closure_graph]
Theorem: Matrix.coe_units_inv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B : Matrix n n α
A : (Matrix n n α)ˣ
⊢ ↑A⁻¹ = (↑A)⁻¹
state_after: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B : Matrix n n α
A : (Matrix n n α)ˣ
this : Invertible ↑A := A.invertible
⊢ ↑A⁻¹ = (↑A)⁻¹
tactic: letI := A.invertible
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B : Matrix n n α
A : (Matrix n n α)ˣ
this : Invertible ↑A := A.invertible
⊢ ↑A⁻¹ = (↑A)⁻¹
state_after: no goals
tactic: rw [← invOf_eq_nonsing_inv, invOf_units]
Theorem: Set.Infinite.exists_not_mem_finite
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
hs : s.Infinite
ht : t.Finite
⊢ ∃ a ∈ s, a ∉ t
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
hs : s.Infinite
ht : t.Finite
h : ∀ a ∈ s, a ∈ t
⊢ False
tactic: by_contra! h
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
hs : s.Infinite
ht : t.Finite
h : ∀ a ∈ s, a ∈ t
⊢ False
state_after: no goals
tactic: exact hs <| ht.subset h
Theorem: isBigO_at_im_infty_jacobiTheta_sub_one
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/OneVariable.lean

Proof steps:
state_before: ⊢ (fun τ => jacobiTheta τ - 1) =O[comap im atTop] fun τ => rexp (-π * τ.im)
state_after: ⊢ ∃ c a, ∀ b ≥ a, ∀ (a : ℂ), a.im = b → ‖jacobiTheta a - 1‖ ≤ c * ‖rexp (-π * a.im)‖
tactic: simp_rw [IsBigO, IsBigOWith, Filter.eventually_comap, Filter.eventually_atTop]
state_before: ⊢ ∃ c a, ∀ b ≥ a, ∀ (a : ℂ), a.im = b → ‖jacobiTheta a - 1‖ ≤ c * ‖rexp (-π * a.im)‖
state_after: y : ℝ
hy : y ≥ 1
τ : ℂ
hτ : τ.im = y
⊢ 2 / (1 - rexp (-π * τ.im)) * rexp (-π * τ.im) ≤ 2 / (1 - rexp (-π)) * ‖rexp (-π * τ.im)‖
tactic: refine ⟨2 / (1 - rexp (-π)), 1, fun y hy τ hτ =>
    (norm_jacobiTheta_sub_one_le (hτ.symm ▸ zero_lt_one.trans_le hy : 0 < im τ)).trans ?_⟩
state_before: y : ℝ
hy : y ≥ 1
τ : ℂ
hτ : τ.im = y
⊢ 2 / (1 - rexp (-π * τ.im)) * rexp (-π * τ.im) ≤ 2 / (1 - rexp (-π)) * ‖rexp (-π * τ.im)‖
state_after: y : ℝ
hy : y ≥ 1
τ : ℂ
hτ : τ.im = y
⊢ 2 / (1 - rexp (-π * τ.im)) * rexp (-π * τ.im) ≤ 2 / (1 - rexp (-π)) * rexp (-π * τ.im)
tactic: rw [Real.norm_eq_abs, Real.abs_exp]
state_before: y : ℝ
hy : y ≥ 1
τ : ℂ
hτ : τ.im = y
⊢ 2 / (1 - rexp (-π * τ.im)) * rexp (-π * τ.im) ≤ 2 / (1 - rexp (-π)) * rexp (-π * τ.im)
state_after: y : ℝ
hy : y ≥ 1
τ : ℂ
hτ : τ.im = y
⊢ 2 / (1 - rexp (-π * τ.im)) ≤ 2 / (1 - rexp (-π))
tactic: refine mul_le_mul_of_nonneg_right ?_ (exp_pos _).le
state_before: y : ℝ
hy : y ≥ 1
τ : ℂ
hτ : τ.im = y
⊢ 2 / (1 - rexp (-π * τ.im)) ≤ 2 / (1 - rexp (-π))
state_after: y : ℝ
hy : y ≥ 1
τ : ℂ
hτ : τ.im = y
⊢ π ≤ π * τ.im

case hb
y : ℝ
hy : y ≥ 1
τ : ℂ
hτ : τ.im = y
⊢ 0 < 1 - rexp (-π * τ.im)

case hc
y : ℝ
hy : y ≥ 1
τ : ℂ
hτ : τ.im = y
⊢ 0 < 1 - rexp (-π)
tactic: rw [div_le_div_left (zero_lt_two' ℝ), sub_le_sub_iff_left, exp_le_exp, neg_mul, neg_le_neg_iff]
Theorem: WittVector.neg_coeff
File: Mathlib/RingTheory/WittVector/Defs.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
n : ℕ
⊢ (-x).coeff n = peval (wittNeg p n) ![x.coeff]
state_after: no goals
tactic: simp [Neg.neg, eval, Matrix.cons_fin_one, coeff_mk]
Theorem: Nat.digits_lt_base'
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n b m : ℕ
⊢ ∀ {d : ℕ}, d ∈ (b + 2).digits m → d < b + 2
state_after: n b m : ℕ
⊢ ∀ (n : ℕ), (∀ m < n, ∀ {d : ℕ}, d ∈ (b + 2).digits m → d < b + 2) → ∀ {d : ℕ}, d ∈ (b + 2).digits n → d < b + 2
tactic: apply Nat.strongInductionOn m
state_before: n b m : ℕ
⊢ ∀ (n : ℕ), (∀ m < n, ∀ {d : ℕ}, d ∈ (b + 2).digits m → d < b + 2) → ∀ {d : ℕ}, d ∈ (b + 2).digits n → d < b + 2
state_after: n✝ b m n : ℕ
IH : ∀ m < n, ∀ {d : ℕ}, d ∈ (b + 2).digits m → d < b + 2
d : ℕ
hd : d ∈ (b + 2).digits n
⊢ d < b + 2
tactic: intro n IH d hd
state_before: n✝ b m n : ℕ
IH : ∀ m < n, ∀ {d : ℕ}, d ∈ (b + 2).digits m → d < b + 2
d : ℕ
hd : d ∈ (b + 2).digits n
⊢ d < b + 2
state_after: case zero
n b m d : ℕ
IH : ∀ m < 0, ∀ {d : ℕ}, d ∈ (b + 2).digits m → d < b + 2
hd : d ∈ (b + 2).digits 0
⊢ d < b + 2

case succ
n✝ b m d n : ℕ
IH : ∀ m < n + 1, ∀ {d : ℕ}, d ∈ (b + 2).digits m → d < b + 2
hd : d ∈ (b + 2).digits (n + 1)
⊢ d < b + 2
tactic: cases' n with n
state_before: case succ
n✝ b m d n : ℕ
IH : ∀ m < n + 1, ∀ {d : ℕ}, d ∈ (b + 2).digits m → d < b + 2
hd : d ∈ (b + 2).digits (n + 1)
⊢ d < b + 2
state_after: case succ
n✝ b m d n : ℕ
IH : ∀ m < n + 1, ∀ {d : ℕ}, d ∈ (b + 2).digits m → d < b + 2
hd : d ∈ (n + 1) % (b + 2) :: (b + 2).digits ((n + 1) / (b + 2))
⊢ d < b + 2
tactic: rw [digits_add_two_add_one] at hd
state_before: case succ
n✝ b m d n : ℕ
IH : ∀ m < n + 1, ∀ {d : ℕ}, d ∈ (b + 2).digits m → d < b + 2
hd : d ∈ (n + 1) % (b + 2) :: (b + 2).digits ((n + 1) / (b + 2))
⊢ d < b + 2
state_after: case succ.head
n✝ b m n : ℕ
IH : ∀ m < n + 1, ∀ {d : ℕ}, d ∈ (b + 2).digits m → d < b + 2
⊢ (n + 1) % (b + 2) < b + 2

case succ.tail
n✝ b m d n : ℕ
IH : ∀ m < n + 1, ∀ {d : ℕ}, d ∈ (b + 2).digits m → d < b + 2
a✝ : List.Mem d ((b + 2).digits ((n + 1) / (b + 2)))
⊢ d < b + 2
tactic: cases hd
Theorem: odd_abs
File: Mathlib/Algebra/Order/Ring/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : Ring α
a : α
⊢ Odd |a| ↔ Odd a
state_after: no goals
tactic: cases' abs_choice a with h h <;> simp only [h, odd_neg]
Theorem: FirstOrder.Language.DirectLimit.exists_of
File: Mathlib/ModelTheory/DirectLimit.lean

Proof steps:
state_before: L : Language
ι : Type v
inst✝⁴ : Preorder ι
G : ι → Type w
inst✝³ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝² : IsDirected ι fun x x_1 => x ≤ x_1
inst✝¹ : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝ : Nonempty ι
z : DirectLimit G f
⊢ (of L ι G f (Quotient.out z).fst) (Quotient.out z).snd = z
state_after: no goals
tactic: simp
Theorem: MulAction.stabilizer_univ
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
⊢ stabilizer G univ = ⊤
state_after: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a x✝ : G
⊢ x✝ ∈ stabilizer G univ ↔ x✝ ∈ ⊤
tactic: ext
state_before: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a x✝ : G
⊢ x✝ ∈ stabilizer G univ ↔ x✝ ∈ ⊤
state_after: no goals
tactic: simp
Theorem: Fintype.prod_eq_one_iff_of_le_one
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : Fintype ι
inst✝ : OrderedCommMonoid M
f : ι → M
hf : f ≤ 1
⊢ (∀ i ∈ Finset.univ, f i = 1) ↔ f = 1
state_after: no goals
tactic: simp [Function.funext_iff]
Theorem: Nat.leRec_succ
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
motive : (m : ℕ) → n ≤ m → Sort u_1
refl : motive n ⋯
le_succ_of_le : ⦃k : ℕ⦄ → (h : n ≤ k) → motive k h → motive (k + 1) ⋯
h1 : n ≤ m
h2 : n ≤ m + 1
⊢ leRec refl le_succ_of_le h2 = le_succ_of_le h1 (leRec refl le_succ_of_le h1)
state_after: no goals
tactic: conv =>
    lhs
    rw [leRec, Or.by_cases, dif_pos h1]
Theorem: Real.Angle.cos_sq_add_sin_sq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : Angle
⊢ θ.cos ^ 2 + θ.sin ^ 2 = 1
state_after: case h
x✝ : ℝ
⊢ (↑x✝).cos ^ 2 + (↑x✝).sin ^ 2 = 1
tactic: induction θ using Real.Angle.induction_on
state_before: case h
x✝ : ℝ
⊢ (↑x✝).cos ^ 2 + (↑x✝).sin ^ 2 = 1
state_after: no goals
tactic: exact Real.cos_sq_add_sin_sq _
Theorem: div_pos_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
⊢ 0 < a / b ↔ 0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0
state_after: no goals
tactic: simp only [division_def, mul_pos_iff, inv_pos, inv_lt_zero]
Theorem: nontrivial_of_hasRankNullity
File: Mathlib/LinearAlgebra/Dimension/RankNullity.lean

Proof steps:
state_before: R : Type u_1
M M₁ M₂ M₃ : Type u
M' : Type v
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M₁
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'
inst✝ : HasRankNullity.{u, u_1} R
⊢ Nontrivial R
state_after: R : Type u_1
M M₁ M₂ M₃ : Type u
M' : Type v
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M₁
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'
inst✝ : HasRankNullity.{u, u_1} R
H : Subsingleton R
⊢ False
tactic: refine (subsingleton_or_nontrivial R).resolve_left fun H ↦ ?_
state_before: R : Type u_1
M M₁ M₂ M₃ : Type u
M' : Type v
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M₁
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'
inst✝ : HasRankNullity.{u, u_1} R
H : Subsingleton R
⊢ False
state_after: R : Type u_1
M M₁ M₂ M₃ : Type u
M' : Type v
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M₁
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'
inst✝ : HasRankNullity.{u, u_1} R
H : Subsingleton R
this : Module.rank R (PUnit.{u + 1} ⧸ ⊥) + Module.rank R ↥⊥ = Module.rank R PUnit.{u + 1}
⊢ False
tactic: have := rank_quotient_add_rank (R := R) (M := PUnit) ⊥
state_before: R : Type u_1
M M₁ M₂ M₃ : Type u
M' : Type v
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M₁
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'
inst✝ : HasRankNullity.{u, u_1} R
H : Subsingleton R
this : Module.rank R (PUnit.{u + 1} ⧸ ⊥) + Module.rank R ↥⊥ = Module.rank R PUnit.{u + 1}
⊢ False
state_after: no goals
tactic: simp [one_add_one_eq_two] at this
Theorem: QuotientGroup.mk_out'_eq_mul
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
g : α
⊢ Quotient.out' ↑g = g * ↑⟨g⁻¹ * Quotient.out' ↑g, ⋯⟩
state_after: no goals
tactic: rw [mul_inv_cancel_left]
Theorem: TypeVec.diag_sub_val
File: Mathlib/Data/TypeVec.lean

Proof steps:
state_before: n✝ n : ℕ
α : TypeVec.{u} n
⊢ subtypeVal α.repeatEq ⊚ diagSub = prod.diag
state_after: case a.h
n✝ n : ℕ
α : TypeVec.{u} n
i : Fin2 n
x : α i
⊢ (subtypeVal α.repeatEq ⊚ diagSub) i x = prod.diag i x
tactic: ext i x
state_before: case a.h
n✝ n : ℕ
α : TypeVec.{u} n
i : Fin2 n
x : α i
⊢ (subtypeVal α.repeatEq ⊚ diagSub) i x = prod.diag i x
state_after: case a.h.fz
n✝¹ n n✝ : ℕ
α : TypeVec.{u} (n✝ + 1)
x : α Fin2.fz
⊢ (subtypeVal α.repeatEq ⊚ diagSub) Fin2.fz x = prod.diag Fin2.fz x

case a.h.fs
n✝¹ n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec.{u} n✝} (x : α a✝), (subtypeVal α.repeatEq ⊚ diagSub) a✝ x = prod.diag a✝ x
α : TypeVec.{u} (n✝ + 1)
x : α a✝.fs
⊢ (subtypeVal α.repeatEq ⊚ diagSub) a✝.fs x = prod.diag a✝.fs x
tactic: induction' i with _ _ _ i_ih
state_before: case a.h.fs
n✝¹ n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec.{u} n✝} (x : α a✝), (subtypeVal α.repeatEq ⊚ diagSub) a✝ x = prod.diag a✝ x
α : TypeVec.{u} (n✝ + 1)
x : α a✝.fs
⊢ (subtypeVal α.repeatEq ⊚ diagSub) a✝.fs x = prod.diag a✝.fs x
state_after: no goals
tactic: apply @i_ih (drop α)
Theorem: Int.natAbs_inj_of_nonpos_of_nonpos
File: Mathlib/Data/Int/Lemmas.lean

Proof steps:
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
ha : a ≤ 0
hb : b ≤ 0
⊢ a.natAbs = b.natAbs ↔ a = b
state_after: no goals
tactic: simpa only [Int.natAbs_neg, neg_inj] using
    natAbs_inj_of_nonneg_of_nonneg (neg_nonneg_of_nonpos ha) (neg_nonneg_of_nonpos hb)
Theorem: IsIdempotentElem.pow_succ_eq
File: Mathlib/Algebra/Ring/Idempotents.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
S : Type u_3
M₀ : Type u_4
M₁ : Type u_5
R : Type u_6
G : Type u_7
G₀ : Type u_8
inst✝⁷ : Mul M
inst✝⁶ : Monoid N
inst✝⁵ : Semigroup S
inst✝⁴ : MulZeroClass M₀
inst✝³ : MulOneClass M₁
inst✝² : NonAssocRing R
inst✝¹ : Group G
inst✝ : CancelMonoidWithZero G₀
p : N
n✝ : ℕ
h : IsIdempotentElem p
n : ℕ
ih : p ^ (n + 1) = p
⊢ p ^ (n.succ + 1) = p
state_after: no goals
tactic: rw [pow_succ, ih, h.eq]
Theorem: MeasureTheory.L1.dist_def
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 g : ↥(Lp β 1 μ)
⊢ dist f g = (∫⁻ (a : α), edist (↑↑f a) (↑↑g a) ∂μ).toReal
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : ↥(Lp β 1 μ)
⊢ (if 1 = ⊤ then eLpNormEssSup (↑↑f - ↑↑g) μ else ∫⁻ (a : α), ↑‖↑↑f a - ↑↑g a‖₊ ∂μ).toReal =
    (∫⁻ (a : α), edist (↑↑f a) (↑↑g a) ∂μ).toReal
tactic: simp only [Lp.dist_def, eLpNorm, one_ne_zero, eLpNorm', Pi.sub_apply, one_toReal,
    ENNReal.rpow_one, ne_eq, not_false_eq_true, div_self, ite_false]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : ↥(Lp β 1 μ)
⊢ (if 1 = ⊤ then eLpNormEssSup (↑↑f - ↑↑g) μ else ∫⁻ (a : α), ↑‖↑↑f a - ↑↑g a‖₊ ∂μ).toReal =
    (∫⁻ (a : α), edist (↑↑f a) (↑↑g a) ∂μ).toReal
state_after: no goals
tactic: simp [edist_eq_coe_nnnorm_sub]
Theorem: EuclideanGeometry.angle_add_angle_add_angle_eq_pi
File: Mathlib/Geometry/Euclidean/Triangle.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h2 : p2 ≠ p1
h3 : p3 ≠ p1
⊢ ∠ p1 p2 p3 + ∠ p2 p3 p1 + ∠ p3 p1 p2 = π
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h2 : p2 ≠ p1
h3 : p3 ≠ p1
⊢ ∠ p3 p1 p2 + ∠ p1 p3 p2 + ∠ p1 p2 p3 = π
tactic: rw [add_assoc, add_comm, add_comm (∠ p2 p3 p1), angle_comm p2 p3 p1]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h2 : p2 ≠ p1
h3 : p3 ≠ p1
⊢ ∠ p3 p1 p2 + ∠ p1 p3 p2 + ∠ p1 p2 p3 = π
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h2 : p2 ≠ p1
h3 : p3 ≠ p1
⊢ InnerProductGeometry.angle (p3 -ᵥ p1) (p2 -ᵥ p1) + InnerProductGeometry.angle (p1 -ᵥ p3) (p2 -ᵥ p3) +
      InnerProductGeometry.angle (p1 -ᵥ p2) (p3 -ᵥ p2) =
    π
tactic: unfold angle
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h2 : p2 ≠ p1
h3 : p3 ≠ p1
⊢ InnerProductGeometry.angle (p3 -ᵥ p1) (p2 -ᵥ p1) + InnerProductGeometry.angle (p1 -ᵥ p3) (p2 -ᵥ p3) +
      InnerProductGeometry.angle (p1 -ᵥ p2) (p3 -ᵥ p2) =
    π
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h2 : p2 ≠ p1
h3 : p3 ≠ p1
⊢ InnerProductGeometry.angle (p3 -ᵥ p1) (p2 -ᵥ p1) + InnerProductGeometry.angle (p3 -ᵥ p1) (p3 -ᵥ p1 - (p2 -ᵥ p1)) +
      InnerProductGeometry.angle (p2 -ᵥ p1) (p2 -ᵥ p1 - (p3 -ᵥ p1)) =
    π
tactic: rw [← angle_neg_neg (p1 -ᵥ p3), ← angle_neg_neg (p1 -ᵥ p2), neg_vsub_eq_vsub_rev,
    neg_vsub_eq_vsub_rev, neg_vsub_eq_vsub_rev, neg_vsub_eq_vsub_rev, ←
    vsub_sub_vsub_cancel_right p3 p2 p1, ← vsub_sub_vsub_cancel_right p2 p3 p1]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h2 : p2 ≠ p1
h3 : p3 ≠ p1
⊢ InnerProductGeometry.angle (p3 -ᵥ p1) (p2 -ᵥ p1) + InnerProductGeometry.angle (p3 -ᵥ p1) (p3 -ᵥ p1 - (p2 -ᵥ p1)) +
      InnerProductGeometry.angle (p2 -ᵥ p1) (p2 -ᵥ p1 - (p3 -ᵥ p1)) =
    π
state_after: no goals
tactic: exact angle_add_angle_sub_add_angle_sub_eq_pi (fun he => h3 (vsub_eq_zero_iff_eq.1 he)) fun he =>
    h2 (vsub_eq_zero_iff_eq.1 he)
Theorem: Ordinal.infinite_pigeonhole
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < (#β).ord.cof
⊢ ∃ a, #↑(f ⁻¹' {a}) = #β
state_after: α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < (#β).ord.cof
this : ∃ a, #β ≤ #↑(f ⁻¹' {a})
⊢ ∃ a, #↑(f ⁻¹' {a}) = #β
tactic: have : ∃ a, #β ≤ #(f ⁻¹' {a}) := by
    by_contra! h
    apply mk_univ.not_lt
    rw [← preimage_univ, ← iUnion_of_singleton, preimage_iUnion]
    exact
      mk_iUnion_le_sum_mk.trans_lt
        ((sum_le_iSup _).trans_lt <| mul_lt_of_lt h₁ (h₂.trans_le <| cof_ord_le _) (iSup_lt h₂ h))
state_before: α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < (#β).ord.cof
this : ∃ a, #β ≤ #↑(f ⁻¹' {a})
⊢ ∃ a, #↑(f ⁻¹' {a}) = #β
state_after: case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < (#β).ord.cof
x : α
h : #β ≤ #↑(f ⁻¹' {x})
⊢ ∃ a, #↑(f ⁻¹' {a}) = #β
tactic: cases' this with x h
state_before: case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < (#β).ord.cof
x : α
h : #β ≤ #↑(f ⁻¹' {x})
⊢ ∃ a, #↑(f ⁻¹' {a}) = #β
state_after: case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < (#β).ord.cof
x : α
h : #β ≤ #↑(f ⁻¹' {x})
⊢ #↑(f ⁻¹' {x}) ≤ #β
tactic: refine ⟨x, h.antisymm' ?_⟩
state_before: case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < (#β).ord.cof
x : α
h : #β ≤ #↑(f ⁻¹' {x})
⊢ #↑(f ⁻¹' {x}) ≤ #β
state_after: case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < (#β).ord.cof
x : α
h : #β ≤ #↑(f ⁻¹' {x})
⊢ ∃ p, #↑p = #↑(f ⁻¹' {x})
tactic: rw [le_mk_iff_exists_set]
state_before: case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < (#β).ord.cof
x : α
h : #β ≤ #↑(f ⁻¹' {x})
⊢ ∃ p, #↑p = #↑(f ⁻¹' {x})
state_after: no goals
tactic: exact ⟨_, rfl⟩
Theorem: Ideal.map_includeRight_eq
File: Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
A : Type u_2
B : Type u_3
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
I : Ideal B
⊢ Submodule.restrictScalars R (map includeRight I) =
    LinearMap.range (LinearMap.lTensor A (Submodule.restrictScalars R I).subtype)
state_after: R : Type u_1
inst✝⁴ : CommSemiring R
A : Type u_2
B : Type u_3
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
I : Ideal B
⊢ (Submodule.restrictScalars R (map includeRight I)).carrier =
    (LinearMap.range (LinearMap.lTensor A (Submodule.restrictScalars R I).subtype)).carrier
tactic: rw [← Submodule.carrier_inj]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
A : Type u_2
B : Type u_3
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
I : Ideal B
⊢ (Submodule.restrictScalars R (map includeRight I)).carrier =
    (LinearMap.range (LinearMap.lTensor A (Submodule.restrictScalars R I).subtype)).carrier
state_after: case a
R : Type u_1
inst✝⁴ : CommSemiring R
A : Type u_2
B : Type u_3
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
I : Ideal B
⊢ (Submodule.restrictScalars R (map includeRight I)).carrier ≤
    (LinearMap.range (LinearMap.lTensor A (Submodule.restrictScalars R I).subtype)).carrier

case a
R : Type u_1
inst✝⁴ : CommSemiring R
A : Type u_2
B : Type u_3
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
I : Ideal B
⊢ (LinearMap.range (LinearMap.lTensor A (Submodule.restrictScalars R I).subtype)).carrier ≤
    (Submodule.restrictScalars R (map includeRight I)).carrier
tactic: apply le_antisymm
Theorem: PEquiv.mem_single_iff
File: Mathlib/Data/PEquiv.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
a₁ a₂ : α
b₁ b₂ : β
⊢ b₁ ∈ (single a₂ b₂) a₁ ↔ a₁ = a₂ ∧ b₁ = b₂
state_after: α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
a₁ a₂ : α
b₁ b₂ : β
⊢ (b₁ ∈ if a₁ = a₂ then some b₂ else none) ↔ a₁ = a₂ ∧ b₁ = b₂
tactic: dsimp [single]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
a₁ a₂ : α
b₁ b₂ : β
⊢ (b₁ ∈ if a₁ = a₂ then some b₂ else none) ↔ a₁ = a₂ ∧ b₁ = b₂
state_after: no goals
tactic: split_ifs <;> simp [*, eq_comm]
Theorem: Cardinal.ofENat_lt_nat
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: m : ℕ∞
n : ℕ
⊢ ↑m < ↑n ↔ m < ↑n
state_after: no goals
tactic: norm_cast