1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.Measure.ext_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: rintro rfl s _hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ μ₁ = μ₂ → ∀ (s : Set α), MeasurableSet s → μ₁ s = μ₂ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ : Measure α
s✝ s₁ s₂ t s : Set α
_hs : MeasurableSet s
⊢ μ₁ s = μ₁ s

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ : Measure α
s✝ s₁ s₂ t s : Set α
_hs : MeasurableSet s
⊢ μ₁ s = μ₁ s
state_after: no goals
Theorem: sSup_iUnion_Iic
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: apply csSup_eq_csSup_of_forall_exists_le
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
f : ι → α
⊢ sSup (⋃ i, Iic (f i)) = ⨆ i, f i
state_after: case hs
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
f : ι → α
⊢ ∀ x ∈ ⋃ i, Iic (f i), ∃ y ∈ range fun i => f i, x ≤ y

case ht
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
f : ι → α
⊢ ∀ y ∈ range fun i => f i, ∃ x ∈ ⋃ i, Iic (f i), y ≤ x

tactic: rintro x ⟨-, ⟨i, rfl⟩, hi⟩
state_before: case hs
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
f : ι → α
⊢ ∀ x ∈ ⋃ i, Iic (f i), ∃ y ∈ range fun i => f i, x ≤ y
state_after: case hs.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
f : ι → α
x : α
i : ι
hi : x ∈ (fun i => Iic (f i)) i
⊢ ∃ y ∈ range fun i => f i, x ≤ y

tactic: exact ⟨f i, mem_range_self _, hi⟩
state_before: case hs.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
f : ι → α
x : α
i : ι
hi : x ∈ (fun i => Iic (f i)) i
⊢ ∃ y ∈ range fun i => f i, x ≤ y
state_after: no goals

tactic: rintro x ⟨i, rfl⟩
state_before: case ht
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
f : ι → α
⊢ ∀ y ∈ range fun i => f i, ∃ x ∈ ⋃ i, Iic (f i), y ≤ x
state_after: case ht.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
f : ι → α
i : ι
⊢ ∃ x ∈ ⋃ i, Iic (f i), (fun i => f i) i ≤ x

tactic: exact ⟨f i, mem_iUnion_of_mem i le_rfl, le_rfl⟩
state_before: case ht.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
f : ι → α
i : ι
⊢ ∃ x ∈ ⋃ i, Iic (f i), (fun i => f i) i ≤ x
state_after: no goals
Theorem: List.take_sum_join'
File: Mathlib/Data/List/Join.lean

tactic: induction L generalizing i
state_before: α : Type u_1
β : Type u_2
L : List (List α)
i : ℕ
⊢ take (Nat.sum (take i (map length L))) L.join = (take i L).join
state_after: case nil
α : Type u_1
β : Type u_2
i : ℕ
⊢ take (Nat.sum (take i (map length []))) [].join = (take i []).join

case cons
α : Type u_1
β : Type u_2
head✝ : List α
tail✝ : List (List α)
tail_ih✝ : ∀ (i : ℕ), take (Nat.sum (take i (map length tail✝))) tail✝.join = (take i tail✝).join
i : ℕ
⊢ take (Nat.sum (take i (map length (head✝ :: tail✝)))) (head✝ :: tail✝).join = (take i (head✝ :: tail✝)).join

tactic: simp
state_before: case nil
α : Type u_1
β : Type u_2
i : ℕ
⊢ take (Nat.sum (take i (map length []))) [].join = (take i []).join
state_after: no goals

tactic: cases i <;> simp [take_append, *]
state_before: case cons
α : Type u_1
β : Type u_2
head✝ : List α
tail✝ : List (List α)
tail_ih✝ : ∀ (i : ℕ), take (Nat.sum (take i (map length tail✝))) tail✝.join = (take i tail✝).join
i : ℕ
⊢ take (Nat.sum (take i (map length (head✝ :: tail✝)))) (head✝ :: tail✝).join = (take i (head✝ :: tail✝)).join
state_after: no goals
Theorem: CategoryTheory.ShortComplex.Exact.isIso_g'
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

tactic: have := hS.mono_g' h
state_before: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Category.{?u.138125, u_2} D
inst✝³ : Preadditive C
inst✝² : Preadditive D
S : ShortComplex C
inst✝¹ : Balanced C
hS : S.Exact
h : S.RightHomologyData
inst✝ : Epi S.g
⊢ IsIso h.g'
state_after: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Category.{?u.138125, u_2} D
inst✝³ : Preadditive C
inst✝² : Preadditive D
S : ShortComplex C
inst✝¹ : Balanced C
hS : S.Exact
h : S.RightHomologyData
inst✝ : Epi S.g
this : Mono h.g'
⊢ IsIso h.g'

tactic: have := epi_of_epi_fac h.p_g'
state_before: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Category.{?u.138125, u_2} D
inst✝³ : Preadditive C
inst✝² : Preadditive D
S : ShortComplex C
inst✝¹ : Balanced C
hS : S.Exact
h : S.RightHomologyData
inst✝ : Epi S.g
this : Mono h.g'
⊢ IsIso h.g'
state_after: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Category.{?u.138125, u_2} D
inst✝³ : Preadditive C
inst✝² : Preadditive D
S : ShortComplex C
inst✝¹ : Balanced C
hS : S.Exact
h : S.RightHomologyData
inst✝ : Epi S.g
this✝ : Mono h.g'
this : Epi h.g'
⊢ IsIso h.g'

tactic: exact isIso_of_mono_of_epi h.g'
state_before: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Category.{?u.138125, u_2} D
inst✝³ : Preadditive C
inst✝² : Preadditive D
S : ShortComplex C
inst✝¹ : Balanced C
hS : S.Exact
h : S.RightHomologyData
inst✝ : Epi S.g
this✝ : Mono h.g'
this : Epi h.g'
⊢ IsIso h.g'
state_after: no goals
Theorem: pow_div_pow_eventuallyEq_atTop
File: Mathlib/Analysis/Asymptotics/SpecificAsymptotics.lean

tactic: apply (eventually_gt_atTop (0 : 𝕜)).mono fun x hx => _
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
⊢ (fun x => x ^ p / x ^ q) =ᶠ[atTop] fun x => x ^ (↑p - ↑q)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
⊢ ∀ (x : 𝕜), 0 < x → (fun x => x ^ p / x ^ q) x = (fun x => x ^ (↑p - ↑q)) x

tactic: intro x hx
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
⊢ ∀ (x : 𝕜), 0 < x → (fun x => x ^ p / x ^ q) x = (fun x => x ^ (↑p - ↑q)) x
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
x : 𝕜
hx : 0 < x
⊢ (fun x => x ^ p / x ^ q) x = (fun x => x ^ (↑p - ↑q)) x

tactic: simp [zpow_sub₀ hx.ne']
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
x : 𝕜
hx : 0 < x
⊢ (fun x => x ^ p / x ^ q) x = (fun x => x ^ (↑p - ↑q)) x
state_after: no goals
Theorem: Batteries.BinomialHeap.Imp.Heap.WF.size_eq
File: .lake/packages/batteries/Batteries/Data/BinomialHeap/Lemmas.lean

tactic: simp [size, Nat.shiftLeft, size_eq h₂, Nat.pow_succ, Nat.mul_succ]
state_before: α : Type u_1
le : α → α → Bool
n a✝³ : Nat
a✝² : α
a✝¹ : HeapNode α
a✝ : Heap α
left✝ : n ≤ a✝³
h₁ : HeapNode.WF le a✝² a✝¹ a✝³
h₂ : WF le (a✝³ + 1) a✝
⊢ (cons a✝³ a✝² a✝¹ a✝).size = (cons a✝³ a✝² a✝¹ a✝).realSize
state_after: α : Type u_1
le : α → α → Bool
n a✝³ : Nat
a✝² : α
a✝¹ : HeapNode α
a✝ : Heap α
left✝ : n ≤ a✝³
h₁ : HeapNode.WF le a✝² a✝¹ a✝³
h₂ : WF le (a✝³ + 1) a✝
⊢ 1 <<< a✝³ + a✝.realSize = a✝¹.realSize + 1 + a✝.realSize

tactic: simp [Nat.add_assoc, Nat.one_shiftLeft, h₁.realSize_eq, h₂.size_eq]
state_before: α : Type u_1
le : α → α → Bool
n a✝³ : Nat
a✝² : α
a✝¹ : HeapNode α
a✝ : Heap α
left✝ : n ≤ a✝³
h₁ : HeapNode.WF le a✝² a✝¹ a✝³
h₂ : WF le (a✝³ + 1) a✝
⊢ 1 <<< a✝³ + a✝.realSize = a✝¹.realSize + 1 + a✝.realSize
state_after: no goals
Theorem: Matrix.IsAdjMatrix.apply_ne_one_iff
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

tactic: obtain h | h := h.zero_or_one i j <;> simp [h]
state_before: V : Type u_1
α : Type u_2
β : Type u_3
A : Matrix V V α
inst✝¹ : MulZeroOneClass α
inst✝ : Nontrivial α
h : A.IsAdjMatrix
i j : V
⊢ ¬A i j = 1 ↔ A i j = 0
state_after: no goals
Theorem: Real.IsConjExponent.inv_sub_one
File: Mathlib/Data/Real/ConjExponents.lean

tactic: rw [← h.inv_add_inv_conj, sub_add_cancel_left]
state_before: a b p q : ℝ
h : p.IsConjExponent q
⊢ p⁻¹ - 1 = -q⁻¹
state_after: no goals
Theorem: Multiset.rel_zero_right
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [rel_iff]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
r : α → β → Prop
p : γ → δ → Prop
a : Multiset α
⊢ Rel r a 0 ↔ a = 0
state_after: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
r : α → β → Prop
p : γ → δ → Prop
a : Multiset α
⊢ (a = 0 ∧ 0 = 0 ∨ ∃ a_1 b as bs, r a_1 b ∧ Rel r as bs ∧ a = a_1 ::ₘ as ∧ 0 = b ::ₘ bs) ↔ a = 0

tactic: simp
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
r : α → β → Prop
p : γ → δ → Prop
a : Multiset α
⊢ (a = 0 ∧ 0 = 0 ∨ ∃ a_1 b as bs, r a_1 b ∧ Rel r as bs ∧ a = a_1 ::ₘ as ∧ 0 = b ::ₘ bs) ↔ a = 0
state_after: no goals
Theorem: EuclideanGeometry.angle_sub_const
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

tactic: simpa only [vsub_eq_sub] using angle_vsub_const v₁ v₂ v₃ v
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ : P
v₁ v₂ v₃ v : V
⊢ ∠ (v₁ - v) (v₂ - v) (v₃ - v) = ∠ v₁ v₂ v₃
state_after: no goals
Theorem: PiNat.dist_nonneg
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: rcases eq_or_ne x y with (rfl | h)
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
⊢ 0 ≤ dist x y
state_after: case inl
E : ℕ → Type u_1
x : (n : ℕ) → E n
⊢ 0 ≤ dist x x

case inr
E : ℕ → Type u_1
x y : (n : ℕ) → E n
h : x ≠ y
⊢ 0 ≤ dist x y

tactic: simp [dist]
state_before: case inl
E : ℕ → Type u_1
x : (n : ℕ) → E n
⊢ 0 ≤ dist x x
state_after: no goals

tactic: simp [dist, h, zero_le_two]
state_before: case inr
E : ℕ → Type u_1
x y : (n : ℕ) → E n
h : x ≠ y
⊢ 0 ≤ dist x y
state_after: no goals
Theorem: Cardinal.cantorFunctionAux_succ
File: Mathlib/Data/Real/Cardinality.lean

tactic: ext n
state_before: c : ℝ
f✝ g : ℕ → Bool
n : ℕ
f : ℕ → Bool
⊢ (fun n => cantorFunctionAux c f (n + 1)) = fun n => c * cantorFunctionAux c (fun n => f (n + 1)) n
state_after: case h
c : ℝ
f✝ g : ℕ → Bool
n✝ : ℕ
f : ℕ → Bool
n : ℕ
⊢ cantorFunctionAux c f (n + 1) = c * cantorFunctionAux c (fun n => f (n + 1)) n

tactic: cases h : f (n + 1) <;> simp [h, _root_.pow_succ']
state_before: case h
c : ℝ
f✝ g : ℕ → Bool
n✝ : ℕ
f : ℕ → Bool
n : ℕ
⊢ cantorFunctionAux c f (n + 1) = c * cantorFunctionAux c (fun n => f (n + 1)) n
state_after: no goals
Theorem: List.get_insertNth_self
File: Mathlib/Data/List/InsertNth.lean

tactic: rwa [length_insertNth _ _ hn, Nat.lt_succ_iff]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
l : List α
x : α
n : ℕ
hn : n ≤ l.length
⊢ n < (insertNth n x l).length
state_after: no goals

tactic: simp [hn, hn']
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
l : List α
x : α
n : ℕ
hn : n ≤ l.length
hn' : optParam (n < (insertNth n x l).length) ⋯
⊢ (insertNth n x l).get ⟨n, hn'⟩ = x
state_after: no goals
Theorem: SetTheory.PGame.mul_moveLeft_inr
File: Mathlib/SetTheory/Game/Basic.lean

tactic: cases x
state_before: x y : PGame
i : x.RightMoves
j : y.RightMoves
⊢ (x * y).moveLeft (toLeftMovesMul (Sum.inr (i, j))) =
    x.moveRight i * y + x * y.moveRight j - x.moveRight i * y.moveRight j
state_after: case mk
y : PGame
j : y.RightMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (mk α✝ β✝ a✝¹ a✝ * y).moveLeft (toLeftMovesMul (Sum.inr (i, j))) =
    (mk α✝ β✝ a✝¹ a✝).moveRight i * y + mk α✝ β✝ a✝¹ a✝ * y.moveRight j - (mk α✝ β✝ a✝¹ a✝).moveRight i * y.moveRight j

tactic: cases y
state_before: case mk
y : PGame
j : y.RightMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (mk α✝ β✝ a✝¹ a✝ * y).moveLeft (toLeftMovesMul (Sum.inr (i, j))) =
    (mk α✝ β✝ a✝¹ a✝).moveRight i * y + mk α✝ β✝ a✝¹ a✝ * y.moveRight j - (mk α✝ β✝ a✝¹ a✝).moveRight i * y.moveRight j
state_after: case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : (mk α✝¹ β✝¹ a✝³ a✝²).RightMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
j : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝).moveLeft (toLeftMovesMul (Sum.inr (i, j))) =
    (mk α✝¹ β✝¹ a✝³ a✝²).moveRight i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * (mk α✝ β✝ a✝¹ a✝).moveRight j -
      (mk α✝¹ β✝¹ a✝³ a✝²).moveRight i * (mk α✝ β✝ a✝¹ a✝).moveRight j

tactic: rfl
state_before: case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : (mk α✝¹ β✝¹ a✝³ a✝²).RightMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
j : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝).moveLeft (toLeftMovesMul (Sum.inr (i, j))) =
    (mk α✝¹ β✝¹ a✝³ a✝²).moveRight i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * (mk α✝ β✝ a✝¹ a✝).moveRight j -
      (mk α✝¹ β✝¹ a✝³ a✝²).moveRight i * (mk α✝ β✝ a✝¹ a✝).moveRight j
state_after: no goals
Theorem: Matrix.mulVec_injective_iff_isUnit
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [← isUnit_transpose, ← vecMul_injective_iff_isUnit]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁴ : DecidableEq m
inst✝³ : DecidableEq n
R : Type u_2
K : Type u_3
inst✝² : CommRing R
inst✝¹ : Field K
inst✝ : Fintype m
A : Matrix m m K
⊢ Function.Injective A.mulVec ↔ IsUnit A
state_after: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁴ : DecidableEq m
inst✝³ : DecidableEq n
R : Type u_2
K : Type u_3
inst✝² : CommRing R
inst✝¹ : Field K
inst✝ : Fintype m
A : Matrix m m K
⊢ Function.Injective A.mulVec ↔ Function.Injective fun v => v ᵥ* Aᵀ

tactic: simp_rw [vecMul_transpose]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁴ : DecidableEq m
inst✝³ : DecidableEq n
R : Type u_2
K : Type u_3
inst✝² : CommRing R
inst✝¹ : Field K
inst✝ : Fintype m
A : Matrix m m K
⊢ Function.Injective A.mulVec ↔ Function.Injective fun v => v ᵥ* Aᵀ
state_after: no goals
Theorem: Matrix.invOf_fromBlocks_zero₂₁_eq
File: Mathlib/LinearAlgebra/Matrix/SchurComplement.lean

tactic: letI := fromBlocksZero₂₁Invertible A B D
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁹ : Fintype l
inst✝⁸ : Fintype m
inst✝⁷ : Fintype n
inst✝⁶ : DecidableEq l
inst✝⁵ : DecidableEq m
inst✝⁴ : DecidableEq n
inst✝³ : CommRing α
A : Matrix m m α
B : Matrix m n α
D : Matrix n n α
inst✝² : Invertible A
inst✝¹ : Invertible D
inst✝ : Invertible (fromBlocks A B 0 D)
⊢ ⅟(fromBlocks A B 0 D) = fromBlocks (⅟A) (-(⅟A * B * ⅟D)) 0 ⅟D
state_after: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁹ : Fintype l
inst✝⁸ : Fintype m
inst✝⁷ : Fintype n
inst✝⁶ : DecidableEq l
inst✝⁵ : DecidableEq m
inst✝⁴ : DecidableEq n
inst✝³ : CommRing α
A : Matrix m m α
B : Matrix m n α
D : Matrix n n α
inst✝² : Invertible A
inst✝¹ : Invertible D
inst✝ : Invertible (fromBlocks A B 0 D)
this : Invertible (fromBlocks A B 0 D) := A.fromBlocksZero₂₁Invertible B D
⊢ ⅟(fromBlocks A B 0 D) = fromBlocks (⅟A) (-(⅟A * B * ⅟D)) 0 ⅟D

tactic: convert (rfl : ⅟ (fromBlocks A B 0 D) = _)
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁹ : Fintype l
inst✝⁸ : Fintype m
inst✝⁷ : Fintype n
inst✝⁶ : DecidableEq l
inst✝⁵ : DecidableEq m
inst✝⁴ : DecidableEq n
inst✝³ : CommRing α
A : Matrix m m α
B : Matrix m n α
D : Matrix n n α
inst✝² : Invertible A
inst✝¹ : Invertible D
inst✝ : Invertible (fromBlocks A B 0 D)
this : Invertible (fromBlocks A B 0 D) := A.fromBlocksZero₂₁Invertible B D
⊢ ⅟(fromBlocks A B 0 D) = fromBlocks (⅟A) (-(⅟A * B * ⅟D)) 0 ⅟D
state_after: no goals
Theorem: IsUnit.det_zpow
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: cases' n with n n
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit A.det
n : ℤ
⊢ IsUnit (A ^ n).det
state_after: case ofNat
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit A.det
n : ℕ
⊢ IsUnit (A ^ ofNat n).det

case negSucc
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit A.det
n : ℕ
⊢ IsUnit (A ^ -[n+1]).det

tactic: simpa using h.pow n
state_before: case ofNat
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit A.det
n : ℕ
⊢ IsUnit (A ^ ofNat n).det
state_after: no goals

tactic: simpa using h.pow n.succ
state_before: case negSucc
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit A.det
n : ℕ
⊢ IsUnit (A ^ -[n+1]).det
state_after: no goals
Theorem: Function.LeftInverse.eq_rightInverse
File: Mathlib/Logic/Function/Basic.lean

tactic: rw [h₂.comp_eq_id, comp_id]
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ f : α → β
g₁ g₂ : β → α
h₁ : LeftInverse g₁ f
h₂ : RightInverse g₂ f
⊢ g₁ = g₁ ∘ f ∘ g₂
state_after: no goals

tactic: rw [← comp.assoc, h₁.comp_eq_id, id_comp]
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ f : α → β
g₁ g₂ : β → α
h₁ : LeftInverse g₁ f
h₂ : RightInverse g₂ f
⊢ g₁ ∘ f ∘ g₂ = g₂
state_after: no goals
Theorem: UFModel.Models.setParent
File: Mathlib/Data/UnionFind.lean

tactic: simp [UFModel.setParent, h.symm]
state_before: α : Type u_1
arr : Array (UFNode α)
n : ℕ
m : UFModel n
hm : Models arr m
i j : Fin n
H : m.rank ↑i < m.rank ↑j
hi : ↑i < arr.size
x : UFNode α
hp : x.parent = ↑j
hrk : x.rank = arr[i].rank
k : Fin n
h : ↑k ≠ ↑i
⊢ ↑((m.setParent i j H).parent k) = ↑(m.parent k)
state_after: no goals

tactic: simp [UFModel.setParent, hp]
state_before: α : Type u_1
arr : Array (UFNode α)
n : ℕ
m : UFModel n
hm : Models arr m
i j : Fin n
H : m.rank ↑i < m.rank ↑j
hi : ↑i < arr.size
x : UFNode α
hp : x.parent = ↑j
hrk : x.rank = arr[i].rank
x✝ : ↑⟨↑i, hi⟩ < n
⊢ x.parent = ↑((m.setParent i j H).parent ⟨↑⟨↑i, hi⟩, x✝⟩)
state_after: no goals
Theorem: PerfectClosure.add_aux_left
File: Mathlib/FieldTheory/PerfectClosure.lean

tactic: rw [← iterate_succ_apply, iterate_succ_apply', iterate_succ_apply', ← frobenius_add,
  Nat.succ_add]
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x1 x2 y : ℕ × K
H : R K p x1 x2
n : ℕ
x : K
⊢ R K p ((n, x).1 + y.1, (⇑(frobenius K p))^[y.1] (n, x).2 + (⇑(frobenius K p))^[(n, x).1] y.2)
    ((n + 1, (frobenius K p) x).1 + y.1,
      (⇑(frobenius K p))^[y.1] (n + 1, (frobenius K p) x).2 + (⇑(frobenius K p))^[(n + 1, (frobenius K p) x).1] y.2)
state_after: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x1 x2 y : ℕ × K
H : R K p x1 x2
n : ℕ
x : K
⊢ R K p ((n, x).1 + y.1, (⇑(frobenius K p))^[y.1] (n, x).2 + (⇑(frobenius K p))^[(n, x).1] y.2)
    ((n + y.1).succ, (frobenius K p) ((⇑(frobenius K p))^[y.1] x + (⇑(frobenius K p))^[n] y.2))

tactic: apply R.intro
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x1 x2 y : ℕ × K
H : R K p x1 x2
n : ℕ
x : K
⊢ R K p ((n, x).1 + y.1, (⇑(frobenius K p))^[y.1] (n, x).2 + (⇑(frobenius K p))^[(n, x).1] y.2)
    ((n + y.1).succ, (frobenius K p) ((⇑(frobenius K p))^[y.1] x + (⇑(frobenius K p))^[n] y.2))
state_after: no goals
Theorem: LinearIsometryEquiv.piLpCongrLeft_single
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: funext x
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝¹¹ : Fact (1 ≤ p)
inst✝¹⁰ : Fintype ι
inst✝⁹ : Semiring 𝕜
inst✝⁸ : (i : ι) → SeminormedAddCommGroup (α i)
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (β i)
inst✝⁶ : (i : ι) → Module 𝕜 (α i)
inst✝⁵ : (i : ι) → Module 𝕜 (β i)
c : 𝕜
ι' : Type u_5
inst✝⁴ : Fintype ι'
E : Type u_6
inst✝³ : SeminormedAddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq ι'
e : ι ≃ ι'
i : ι
v : E
⊢ (LinearIsometryEquiv.piLpCongrLeft p 𝕜 E e) ((WithLp.equiv p (ι → E)).symm (Pi.single i v)) =
    (WithLp.equiv p (ι' → E)).symm (Pi.single (e i) v)
state_after: case h
p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝¹¹ : Fact (1 ≤ p)
inst✝¹⁰ : Fintype ι
inst✝⁹ : Semiring 𝕜
inst✝⁸ : (i : ι) → SeminormedAddCommGroup (α i)
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (β i)
inst✝⁶ : (i : ι) → Module 𝕜 (α i)
inst✝⁵ : (i : ι) → Module 𝕜 (β i)
c : 𝕜
ι' : Type u_5
inst✝⁴ : Fintype ι'
E : Type u_6
inst✝³ : SeminormedAddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq ι'
e : ι ≃ ι'
i : ι
v : E
x : ι'
⊢ (LinearIsometryEquiv.piLpCongrLeft p 𝕜 E e) ((WithLp.equiv p (ι → E)).symm (Pi.single i v)) x =
    (WithLp.equiv p (ι' → E)).symm (Pi.single (e i) v) x

tactic: simp [LinearIsometryEquiv.piLpCongrLeft_apply, LinearEquiv.piCongrLeft', Equiv.piCongrLeft',
  Pi.single, Function.update, Equiv.symm_apply_eq]
state_before: case h
p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝¹¹ : Fact (1 ≤ p)
inst✝¹⁰ : Fintype ι
inst✝⁹ : Semiring 𝕜
inst✝⁸ : (i : ι) → SeminormedAddCommGroup (α i)
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (β i)
inst✝⁶ : (i : ι) → Module 𝕜 (α i)
inst✝⁵ : (i : ι) → Module 𝕜 (β i)
c : 𝕜
ι' : Type u_5
inst✝⁴ : Fintype ι'
E : Type u_6
inst✝³ : SeminormedAddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq ι'
e : ι ≃ ι'
i : ι
v : E
x : ι'
⊢ (LinearIsometryEquiv.piLpCongrLeft p 𝕜 E e) ((WithLp.equiv p (ι → E)).symm (Pi.single i v)) x =
    (WithLp.equiv p (ι' → E)).symm (Pi.single (e i) v) x
state_after: no goals
Theorem: dist_dist_dist_le_right
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: simpa only [dist_comm x] using dist_dist_dist_le_left y z x
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
⊢ dist (dist x y) (dist x z) ≤ dist y z
state_after: no goals
Theorem: CategoryTheory.epi_of_nonzero_to_simple
File: Mathlib/CategoryTheory/Simple.lean

tactic: rw [← image.fac f]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
inst✝² : HasEqualizers C
X Y : C
inst✝¹ : Simple Y
f : X ⟶ Y
inst✝ : HasImage f
w : f ≠ 0
⊢ Epi f
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
inst✝² : HasEqualizers C
X Y : C
inst✝¹ : Simple Y
f : X ⟶ Y
inst✝ : HasImage f
w : f ≠ 0
⊢ Epi (factorThruImage f ≫ image.ι f)

tactic: haveI : IsIso (image.ι f) := isIso_of_mono_of_nonzero fun h => w (eq_zero_of_image_eq_zero h)
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
inst✝² : HasEqualizers C
X Y : C
inst✝¹ : Simple Y
f : X ⟶ Y
inst✝ : HasImage f
w : f ≠ 0
⊢ Epi (factorThruImage f ≫ image.ι f)
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
inst✝² : HasEqualizers C
X Y : C
inst✝¹ : Simple Y
f : X ⟶ Y
inst✝ : HasImage f
w : f ≠ 0
this : IsIso (image.ι f)
⊢ Epi (factorThruImage f ≫ image.ι f)

tactic: apply epi_comp
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
inst✝² : HasEqualizers C
X Y : C
inst✝¹ : Simple Y
f : X ⟶ Y
inst✝ : HasImage f
w : f ≠ 0
this : IsIso (image.ι f)
⊢ Epi (factorThruImage f ≫ image.ι f)
state_after: no goals
Theorem: Equiv.removeNone_optionCongr
File: Mathlib/Logic/Equiv/Option.lean

tactic: simp [EquivFunctor.map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e✝ : Option α ≃ Option β
e : α ≃ β
x : α
⊢ e.optionCongr (some x) = some (e x)
state_after: no goals
Theorem: Finsupp.card_pi
File: Mathlib/Data/Finset/Finsupp.lean

tactic: rw [pi, card_finsupp]
state_before: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f✝ : ι →₀ α
f : ι →₀ Finset α
⊢ f.pi.card = f.prod fun i => ↑(f i).card
state_after: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f✝ : ι →₀ α
f : ι →₀ Finset α
⊢ ∏ i ∈ f.support, (f i).card = f.prod fun i => ↑(f i).card

tactic: exact Finset.prod_congr rfl fun i _ => by simp only [Pi.natCast_apply, Nat.cast_id]
state_before: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f✝ : ι →₀ α
f : ι →₀ Finset α
⊢ ∏ i ∈ f.support, (f i).card = f.prod fun i => ↑(f i).card
state_after: no goals

tactic: simp only [Pi.natCast_apply, Nat.cast_id]
state_before: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f✝ : ι →₀ α
f : ι →₀ Finset α
i : ι
x✝ : i ∈ f.support
⊢ (f i).card = (fun i => ↑(f i).card) i (f i)
state_after: no goals