ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Substring.Valid.prevn
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: m₂ m₁ : List Char
x✝ : Substring
h : x✝.Valid
e : x✝.toString.data = m₁.reverse ++ m₂
⊢ ∀ (n : Nat), x✝.prevn n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop n m₁) }
state_after: m₂ m₁ : List Char
x✝ : Substring
h✝ : x✝.Valid
e : x✝.toString.data = m₁.reverse ++ m₂
l m r : List Char
h : ValidFor l m r x✝
⊢ ∀ (n : Nat), x✝.prevn n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop n m₁) }
tactic: let ⟨l, m, r, h⟩ := h.validFor
state_before: m₂ m₁ : List Char
x✝ : Substring
h✝ : x✝.Valid
e : x✝.toString.data = m₁.reverse ++ m₂
l m r : List Char
h : ValidFor l m r x✝
⊢ ∀ (n : Nat), x✝.prevn n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop n m₁) }
state_after: m₂ m₁ : List Char
x✝ : Substring
h✝ : x✝.Valid
l m r : List Char
h : ValidFor l m r x✝
e : m = m₁.reverse ++ m₂
⊢ ∀ (n : Nat), x✝.prevn n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop n m₁) }
tactic: simp only [h.toString] at e
state_before: m₂ m₁ : List Char
x✝ : Substring
h✝ : x✝.Valid
l m r : List Char
h : ValidFor l m r x✝
e : m = m₁.reverse ++ m₂
⊢ ∀ (n : Nat), x✝.prevn n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop n m₁) }
state_after: m₂ m₁ : List Char
x✝ : Substring
h✝ : x✝.Valid
l r : List Char
h : ValidFor l (m₁.reverse ++ m₂) r x✝
⊢ ∀ (n : Nat), x✝.prevn n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop n m₁) }
tactic: subst e
state_before: m₂ m₁ : List Char
x✝ : Substring
h✝ : x✝.Valid
l r : List Char
h : ValidFor l (m₁.reverse ++ m₂) r x✝
⊢ ∀ (n : Nat), x✝.prevn n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop n m₁) }
state_after: no goals
tactic: simp [h.prevn]
Theorem: Bool.and_eq_false_eq_eq_false_or_eq_false
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: a b : Bool
⊢ ((a && b) = false) = (a = false ∨ b = false)
state_after: no goals
tactic: cases a <;> cases b <;> simp
Theorem: Matrix.mul_adjugate_apply
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

Proof steps:
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
i j k : n
⊢ A i k * A.adjugate k j = Aᵀ.cramer (Pi.single k (A i k)) j
state_after: no goals
tactic: erw [← smul_eq_mul, adjugate, of_apply, ← Pi.smul_apply, ← LinearMap.map_smul, ← Pi.single_smul',
    smul_eq_mul, mul_one]
Theorem: Polynomial.degree_le_iff_coeff_zero
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
f : R[X]
n : WithBot ℕ
⊢ f.degree ≤ n ↔ ∀ (m : ℕ), n < ↑m → f.coeff m = 0
state_after: no goals
tactic: simp only [degree, Finset.max, Finset.sup_le_iff, mem_support_iff, Ne, ← not_le,
    not_imp_comm, Nat.cast_withBot]
Theorem: FreeAddGroup.map.id
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x✝ y x : FreeGroup α
⊢ (map _root_.id) x = x
state_after: case mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x✝ y x : FreeGroup α
L : List (α × Bool)
⊢ (map _root_.id) (Quot.mk Red.Step L) = Quot.mk Red.Step L
tactic: rcases x with ⟨L⟩
state_before: case mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x✝ y x : FreeGroup α
L : List (α × Bool)
⊢ (map _root_.id) (Quot.mk Red.Step L) = Quot.mk Red.Step L
state_after: no goals
tactic: simp [List.map_id']
Theorem: EReal.neg_mul
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x y : EReal
⊢ -x * y = -(x * y)
state_after: no goals
tactic: induction x, y using induction₂_neg_left with
  | top_zero | zero_top | zero_bot => simp only [zero_mul, mul_zero, neg_zero]
  | top_top | top_bot => rfl
  | neg_left h => rw [h, neg_neg, neg_neg]
  | coe_coe => norm_cast; exact neg_mul _ _
  | top_pos _ h => rw [top_mul_coe_of_pos h, neg_top, bot_mul_coe_of_pos h]
  | pos_top _ h => rw [coe_mul_top_of_pos h, neg_top, ← coe_neg,
    coe_mul_top_of_neg (neg_neg_of_pos h)]
  | top_neg _ h => rw [top_mul_coe_of_neg h, neg_top, bot_mul_coe_of_neg h, neg_bot]
  | pos_bot _ h => rw [coe_mul_bot_of_pos h, neg_bot, ← coe_neg,
    coe_mul_bot_of_neg (neg_neg_of_pos h)]
Theorem: Set.sInter_iUnion
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : ι → Set (Set α)
⊢ ⋂₀ ⋃ i, s i = ⋂ i, ⋂₀ s i
state_after: no goals
tactic: simp only [sInter_eq_biInter, biInter_iUnion]
Theorem: padicValNat.prime_pow
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p a b : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ padicValNat p (p ^ n) = n
state_after: no goals
tactic: rw [padicValNat.pow _ (@Fact.out p.Prime).ne_zero, padicValNat_self, mul_one]
Theorem: Set.pairwise_insert_of_symmetric_of_not_mem
File: Mathlib/Data/Set/Pairwise/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f g : ι → α
s t u : Set α
a b : α
hr : Symmetric r
ha : a ∉ s
⊢ (insert a s).Pairwise r ↔ s.Pairwise r ∧ ∀ b ∈ s, r a b
state_after: no goals
tactic: simp only [pairwise_insert_of_not_mem ha, hr.iff a, and_self_iff]
Theorem: RingTheory.Sequence.IsWeaklyRegular.isWeaklyRegular_rTensor
File: Mathlib/RingTheory/Regular/RegularSequence.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
M₂ : Type u_4
M₃ : Type u_5
M₄ : Type u_6
inst✝⁹ : CommRing R
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.Flat R M₂
rs : List R
h : IsWeaklyRegular M rs
⊢ IsWeaklyRegular (M ⊗[R] M₂) rs
state_after: no goals
tactic: induction h with
  | nil N => exact nil R (N ⊗[R] M₂)
  | @cons N _ _ r rs' h1 _ ih =>
    let e := quotSMulTopTensorEquivQuotSMulTop r M₂ N
    exact ((e.isWeaklyRegular_congr rs').mp ih).cons (h1.rTensor M₂)
Theorem: Pi.ker_ringHom
File: Mathlib/RingTheory/Ideal/Maps.lean

Proof steps:
state_before: R✝ : Type u
S : Type v
T : Type w
F : Type u_1
G : Type u_2
inst✝⁵ : Semiring R✝
inst✝⁴ : Semiring S
inst✝³ : Semiring T
inst✝² : FunLike F R✝ S
rcf : RingHomClass F R✝ S
inst✝¹ : FunLike G T S
rcg : RingHomClass G T S
f : F
g : G
ι : Type u_3
R : ι → Type u_4
inst✝ : (i : ι) → Semiring (R i)
φ : (i : ι) → S →+* R i
⊢ ker (Pi.ringHom φ) = ⨅ i, ker (φ i)
state_after: case h
R✝ : Type u
S : Type v
T : Type w
F : Type u_1
G : Type u_2
inst✝⁵ : Semiring R✝
inst✝⁴ : Semiring S
inst✝³ : Semiring T
inst✝² : FunLike F R✝ S
rcf : RingHomClass F R✝ S
inst✝¹ : FunLike G T S
rcg : RingHomClass G T S
f : F
g : G
ι : Type u_3
R : ι → Type u_4
inst✝ : (i : ι) → Semiring (R i)
φ : (i : ι) → S →+* R i
x : S
⊢ x ∈ ker (Pi.ringHom φ) ↔ x ∈ ⨅ i, ker (φ i)
tactic: ext x
state_before: case h
R✝ : Type u
S : Type v
T : Type w
F : Type u_1
G : Type u_2
inst✝⁵ : Semiring R✝
inst✝⁴ : Semiring S
inst✝³ : Semiring T
inst✝² : FunLike F R✝ S
rcf : RingHomClass F R✝ S
inst✝¹ : FunLike G T S
rcg : RingHomClass G T S
f : F
g : G
ι : Type u_3
R : ι → Type u_4
inst✝ : (i : ι) → Semiring (R i)
φ : (i : ι) → S →+* R i
x : S
⊢ x ∈ ker (Pi.ringHom φ) ↔ x ∈ ⨅ i, ker (φ i)
state_after: no goals
tactic: simp [mem_ker, Ideal.mem_iInf, Function.funext_iff]
Theorem: ValuationSubring.ker_unitGroupToResidueFieldUnits
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
A : ValuationSubring K
⊢ A.unitGroupToResidueFieldUnits.ker = Subgroup.comap A.unitGroup.subtype A.principalUnitGroup
state_after: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
x✝ : ↥A.unitGroup
⊢ x✝ ∈ A.unitGroupToResidueFieldUnits.ker ↔ x✝ ∈ Subgroup.comap A.unitGroup.subtype A.principalUnitGroup
tactic: ext
state_before: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
x✝ : ↥A.unitGroup
⊢ x✝ ∈ A.unitGroupToResidueFieldUnits.ker ↔ x✝ ∈ Subgroup.comap A.unitGroup.subtype A.principalUnitGroup
state_after: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
x✝ : ↥A.unitGroup
⊢ x✝ ∈ A.unitGroupToResidueFieldUnits.ker ↔ A.unitGroupMulEquiv x✝ ∈ (Units.map ↑(LocalRing.residue ↥A)).ker
tactic: rw [Subgroup.mem_comap, Subgroup.coeSubtype, coe_mem_principalUnitGroup_iff]
state_before: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
x✝ : ↥A.unitGroup
⊢ x✝ ∈ A.unitGroupToResidueFieldUnits.ker ↔ A.unitGroupMulEquiv x✝ ∈ (Units.map ↑(LocalRing.residue ↥A)).ker
state_after: no goals
tactic: rfl
Theorem: ENNReal.truncateToReal_le
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
t : ℝ≥0∞
t_ne_top : t ≠ ⊤
x : ℝ≥0∞
⊢ t.truncateToReal x ≤ t.toReal
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
t : ℝ≥0∞
t_ne_top : t ≠ ⊤
x : ℝ≥0∞
⊢ (min t x).toReal ≤ t.toReal
tactic: rw [truncateToReal]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
t : ℝ≥0∞
t_ne_top : t ≠ ⊤
x : ℝ≥0∞
⊢ (min t x).toReal ≤ t.toReal
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
t : ℝ≥0∞
t_ne_top : t ≠ ⊤
x : ℝ≥0∞
⊢ min t x ≠ ⊤
tactic: apply (toReal_le_toReal _ t_ne_top).mpr (min_le_left t x)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
t : ℝ≥0∞
t_ne_top : t ≠ ⊤
x : ℝ≥0∞
⊢ min t x ≠ ⊤
state_after: no goals
tactic: simp_all only [ne_eq, min_eq_top, false_and, not_false_eq_true]
Theorem: Multiset.le_cons_of_not_mem
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
s t : Multiset α
a : α
m : a ∉ s
⊢ s ≤ a ::ₘ t ↔ s ≤ t
state_after: α : Type u_1
β : Type v
γ : Type u_2
s t : Multiset α
a : α
m : a ∉ s
⊢ s ≤ a ::ₘ t → s ≤ t
tactic: refine ⟨?_, fun h => le_trans h <| le_cons_self _ _⟩
state_before: α : Type u_1
β : Type v
γ : Type u_2
s t : Multiset α
a : α
m : a ∉ s
⊢ s ≤ a ::ₘ t → s ≤ t
state_after: α : Type u_1
β : Type v
γ : Type u_2
s t : Multiset α
a : α
m : a ∉ s
⊢ ∀ {t' : Multiset α}, s ≤ t' → a ∈ t' → a ::ₘ s ≤ t'
tactic: suffices ∀ {t'}, s ≤ t' → a ∈ t' → a ::ₘ s ≤ t' by
    exact fun h => (cons_le_cons_iff a).1 (this h (mem_cons_self _ _))
state_before: α : Type u_1
β : Type v
γ : Type u_2
s t : Multiset α
a : α
m : a ∉ s
⊢ ∀ {t' : Multiset α}, s ≤ t' → a ∈ t' → a ::ₘ s ≤ t'
state_after: α : Type u_1
β : Type v
γ : Type u_2
s t : Multiset α
a : α
m : a ∉ s
t' : Multiset α
h : s ≤ t'
⊢ a ∈ t' → a ::ₘ s ≤ t'
tactic: introv h
state_before: α : Type u_1
β : Type v
γ : Type u_2
s t : Multiset α
a : α
m : a ∉ s
t' : Multiset α
h : s ≤ t'
⊢ a ∈ t' → a ::ₘ s ≤ t'
state_after: α : Type u_1
β : Type v
γ : Type u_2
s t : Multiset α
a : α
t' : Multiset α
h : s ≤ t'
⊢ a ∉ s → a ∈ t' → a ::ₘ s ≤ t'
tactic: revert m
state_before: α : Type u_1
β : Type v
γ : Type u_2
s t : Multiset α
a : α
t' : Multiset α
h : s ≤ t'
⊢ a ∉ s → a ∈ t' → a ::ₘ s ≤ t'
state_after: α : Type u_1
β : Type v
γ : Type u_2
s t : Multiset α
a : α
t' : Multiset α
h : s ≤ t'
⊢ ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → a ∉ ↑l₁ → a ∈ ↑l₂ → a ::ₘ ↑l₁ ≤ ↑l₂
tactic: refine leInductionOn h ?_
state_before: α : Type u_1
β : Type v
γ : Type u_2
s t : Multiset α
a : α
t' : Multiset α
h : s ≤ t'
⊢ ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → a ∉ ↑l₁ → a ∈ ↑l₂ → a ::ₘ ↑l₁ ≤ ↑l₂
state_after: α : Type u_1
β : Type v
γ : Type u_2
s✝ t : Multiset α
a : α
t' : Multiset α
h : s✝ ≤ t'
l₁ l₂ : List α
s : l₁ <+ l₂
m₁ : a ∉ ↑l₁
m₂ : a ∈ ↑l₂
⊢ a ::ₘ ↑l₁ ≤ ↑l₂
tactic: introv s m₁ m₂
state_before: α : Type u_1
β : Type v
γ : Type u_2
s✝ t : Multiset α
a : α
t' : Multiset α
h : s✝ ≤ t'
l₁ l₂ : List α
s : l₁ <+ l₂
m₁ : a ∉ ↑l₁
m₂ : a ∈ ↑l₂
⊢ a ::ₘ ↑l₁ ≤ ↑l₂
state_after: case intro.intro
α : Type u_1
β : Type v
γ : Type u_2
s✝ t : Multiset α
a : α
t' : Multiset α
h : s✝ ≤ t'
l₁ : List α
m₁ : a ∉ ↑l₁
r₁ r₂ : List α
s : l₁ <+ r₁ ++ a :: r₂
m₂ : a ∈ ↑(r₁ ++ a :: r₂)
⊢ a ::ₘ ↑l₁ ≤ ↑(r₁ ++ a :: r₂)
tactic: rcases append_of_mem m₂ with ⟨r₁, r₂, rfl⟩
state_before: case intro.intro
α : Type u_1
β : Type v
γ : Type u_2
s✝ t : Multiset α
a : α
t' : Multiset α
h : s✝ ≤ t'
l₁ : List α
m₁ : a ∉ ↑l₁
r₁ r₂ : List α
s : l₁ <+ r₁ ++ a :: r₂
m₂ : a ∈ ↑(r₁ ++ a :: r₂)
⊢ a ::ₘ ↑l₁ ≤ ↑(r₁ ++ a :: r₂)
state_after: no goals
tactic: exact
    perm_middle.subperm_left.2
      ((subperm_cons _).2 <| ((sublist_or_mem_of_sublist s).resolve_right m₁).subperm)
Theorem: FDRep.char_orthonormal
File: Mathlib/RepresentationTheory/Character.lean

Proof steps:
state_before: k : Type u
inst✝⁵ : Field k
G : Grp
inst✝⁴ : IsAlgClosed k
inst✝³ : Fintype ↑G
inst✝² : Invertible ↑(Fintype.card ↑G)
V W : FDRep k ↑G
inst✝¹ : Simple V
inst✝ : Simple W
⊢ ⅟↑(Fintype.card ↑G) • ∑ g : ↑G, V.character g * W.character g⁻¹ = if Nonempty (V ≅ W) then 1 else 0
state_after: k : Type u
inst✝⁵ : Field k
G : Grp
inst✝⁴ : IsAlgClosed k
inst✝³ : Fintype ↑G
inst✝² : Invertible ↑(Fintype.card ↑G)
V W : FDRep k ↑G
inst✝¹ : Simple V
inst✝ : Simple W
⊢ ⅟↑(Fintype.card ↑G) • Finset.univ.sum (of (linHom W.ρ V.ρ)).character = if Nonempty (V ≅ W) then 1 else 0
tactic: conv_lhs =>
    enter [2, 2, g]
    rw [mul_comm, ← char_dual, ← Pi.mul_apply, ← char_tensor]
    rw [char_iso (FDRep.dualTensorIsoLinHom W.ρ V)]
state_before: k : Type u
inst✝⁵ : Field k
G : Grp
inst✝⁴ : IsAlgClosed k
inst✝³ : Fintype ↑G
inst✝² : Invertible ↑(Fintype.card ↑G)
V W : FDRep k ↑G
inst✝¹ : Simple V
inst✝ : Simple W
⊢ ⅟↑(Fintype.card ↑G) • Finset.univ.sum (of (linHom W.ρ V.ρ)).character = if Nonempty (V ≅ W) then 1 else 0
state_after: k : Type u
inst✝⁵ : Field k
G : Grp
inst✝⁴ : IsAlgClosed k
inst✝³ : Fintype ↑G
inst✝² : Invertible ↑(Fintype.card ↑G)
V W : FDRep k ↑G
inst✝¹ : Simple V
inst✝ : Simple W
⊢ ↑(finrank k ↥(invariants (of (linHom W.ρ V.ρ)).ρ)) = if Nonempty (V ≅ W) then 1 else 0
tactic: rw [average_char_eq_finrank_invariants]
state_before: k : Type u
inst✝⁵ : Field k
G : Grp
inst✝⁴ : IsAlgClosed k
inst✝³ : Fintype ↑G
inst✝² : Invertible ↑(Fintype.card ↑G)
V W : FDRep k ↑G
inst✝¹ : Simple V
inst✝ : Simple W
⊢ ↑(finrank k ↥(invariants (of (linHom W.ρ V.ρ)).ρ)) = if Nonempty (V ≅ W) then 1 else 0
state_after: k : Type u
inst✝⁵ : Field k
G : Grp
inst✝⁴ : IsAlgClosed k
inst✝³ : Fintype ↑G
inst✝² : Invertible ↑(Fintype.card ↑G)
V W : FDRep k ↑G
inst✝¹ : Simple V
inst✝ : Simple W
⊢ ↑(finrank k ↥(linHom W.ρ V.ρ).invariants) = if Nonempty (V ≅ W) then 1 else 0
tactic: rw [show (of (linHom W.ρ V.ρ)).ρ = linHom W.ρ V.ρ from FDRep.of_ρ (linHom W.ρ V.ρ)]
state_before: k : Type u
inst✝⁵ : Field k
G : Grp
inst✝⁴ : IsAlgClosed k
inst✝³ : Fintype ↑G
inst✝² : Invertible ↑(Fintype.card ↑G)
V W : FDRep k ↑G
inst✝¹ : Simple V
inst✝ : Simple W
⊢ ↑(finrank k ↥(linHom W.ρ V.ρ).invariants) = if Nonempty (V ≅ W) then 1 else 0
state_after: k : Type u
inst✝⁵ : Field k
G : Grp
inst✝⁴ : IsAlgClosed k
inst✝³ : Fintype ↑G
inst✝² : Invertible ↑(Fintype.card ↑G)
V W : FDRep k ↑G
inst✝¹ : Simple V
inst✝ : Simple W
⊢ ↑(finrank k (W ⟶ V)) = if Nonempty (V ≅ W) then 1 else 0
tactic: erw [(linHom.invariantsEquivFDRepHom W V).finrank_eq]
state_before: k : Type u
inst✝⁵ : Field k
G : Grp
inst✝⁴ : IsAlgClosed k
inst✝³ : Fintype ↑G
inst✝² : Invertible ↑(Fintype.card ↑G)
V W : FDRep k ↑G
inst✝¹ : Simple V
inst✝ : Simple W
⊢ ↑(finrank k (W ⟶ V)) = if Nonempty (V ≅ W) then 1 else 0
state_after: no goals
tactic: rw_mod_cast [finrank_hom_simple_simple W V, Iso.nonempty_iso_symm]
Theorem: EuclideanGeometry.dist_div_tan_oangle_right_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.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
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
⊢ dist p₁ p₂ / (∡ p₂ p₃ p₁).tan = dist p₃ p₂
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
hs : (∡ p₂ p₃ p₁).sign = 1
⊢ dist p₁ p₂ / (∡ p₂ p₃ p₁).tan = dist p₃ p₂
tactic: have hs : (∡ p₂ p₃ p₁).sign = 1 := by rw [oangle_rotate_sign, h, Real.Angle.sign_coe_pi_div_two]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
hs : (∡ p₂ p₃ p₁).sign = 1
⊢ dist p₁ p₂ / (∡ p₂ p₃ p₁).tan = dist p₃ p₂
state_after: no goals
tactic: rw [oangle_eq_angle_of_sign_eq_one hs, Real.Angle.tan_coe,
    dist_div_tan_angle_of_angle_eq_pi_div_two (angle_eq_pi_div_two_of_oangle_eq_pi_div_two h)
      (Or.inl (left_ne_of_oangle_eq_pi_div_two h))]
Theorem: AlgebraCat.forget₂_map_associator_inv
File: Mathlib/Algebra/Category/AlgebraCat/Monoidal.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
X Y Z : AlgebraCat R
⊢ (forget₂ (AlgebraCat R) (ModuleCat R)).map (α_ X Y Z).inv =
    (α_ ((forget₂ (AlgebraCat R) (ModuleCat R)).obj X) ((forget₂ (AlgebraCat R) (ModuleCat R)).obj Y)
        ((forget₂ (AlgebraCat R) (ModuleCat R)).obj Z)).inv
state_after: no goals
tactic: rfl
Theorem: ProbabilityTheory.iIndep.meas_iInter
File: Mathlib/Probability/Independence/Basic.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ : Measure Ω
S : Finset ι
s : ι → Set Ω
inst✝ : Fintype ι
hμ : iIndep m μ
hs : ∀ (i : ι), MeasurableSet (s i)
⊢ μ (⋂ i, s i) = ∏ i : ι, μ (s i)
state_after: no goals
tactic: simp [← hμ.meas_biInter fun _ _ ↦ hs _]
Theorem: preimage_coe_mem_nhds_subtype
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝ : (i : ι) → TopologicalSpace (π i)
s t : Set α
a : ↑s
⊢ Subtype.val ⁻¹' t ∈ 𝓝 a ↔ t ∈ 𝓝[s] ↑a
state_after: no goals
tactic: rw [← map_nhds_subtype_val, mem_map]
Theorem: CategoryTheory.enrichedFunctorTypeEquivFunctor_symm_apply_map
File: Mathlib/CategoryTheory/Enriched/Basic.lean

Proof steps:
state_before: V : Type v
inst✝² : Category.{w, v} V
inst✝¹ : MonoidalCategory V
C✝ : Type u₁
inst✝ : EnrichedCategory V C✝
C : Type u₁
𝒞 : EnrichedCategory (Type v) C
D : Type u₂
𝒟 : EnrichedCategory (Type v) D
F : C ⥤ D
X : C
⊢ eId (Type v) X ≫ (fun X Y f => F.map f) X X = eId (Type v) ((fun X => F.obj X) X)
state_after: case h.unit
V : Type v
inst✝² : Category.{w, v} V
inst✝¹ : MonoidalCategory V
C✝ : Type u₁
inst✝ : EnrichedCategory V C✝
C : Type u₁
𝒞 : EnrichedCategory (Type v) C
D : Type u₂
𝒟 : EnrichedCategory (Type v) D
F : C ⥤ D
X : C
⊢ (eId (Type v) X ≫ (fun X Y f => F.map f) X X) PUnit.unit = eId (Type v) ((fun X => F.obj X) X) PUnit.unit
tactic: ext ⟨⟩
state_before: case h.unit
V : Type v
inst✝² : Category.{w, v} V
inst✝¹ : MonoidalCategory V
C✝ : Type u₁
inst✝ : EnrichedCategory V C✝
C : Type u₁
𝒞 : EnrichedCategory (Type v) C
D : Type u₂
𝒟 : EnrichedCategory (Type v) D
F : C ⥤ D
X : C
⊢ (eId (Type v) X ≫ (fun X Y f => F.map f) X X) PUnit.unit = eId (Type v) ((fun X => F.obj X) X) PUnit.unit
state_after: no goals
tactic: exact F.map_id X
state_before: V : Type v
inst✝² : Category.{w, v} V
inst✝¹ : MonoidalCategory V
C✝ : Type u₁
inst✝ : EnrichedCategory V C✝
C : Type u₁
𝒞 : EnrichedCategory (Type v) C
D : Type u₂
𝒟 : EnrichedCategory (Type v) D
F : C ⥤ D
X Y Z : C
⊢ eComp (Type v) X Y Z ≫ (fun X Y f => F.map f) X Z =
    ((fun X Y f => F.map f) X Y ⊗ (fun X Y f => F.map f) Y Z) ≫
      eComp (Type v) ((fun X => F.obj X) X) ((fun X => F.obj X) Y) ((fun X => F.obj X) Z)
state_after: case h.mk
V : Type v
inst✝² : Category.{w, v} V
inst✝¹ : MonoidalCategory V
C✝ : Type u₁
inst✝ : EnrichedCategory V C✝
C : Type u₁
𝒞 : EnrichedCategory (Type v) C
D : Type u₂
𝒟 : EnrichedCategory (Type v) D
F : C ⥤ D
X Y Z : C
f : EnrichedCategory.Hom X Y
g : EnrichedCategory.Hom Y Z
⊢ (eComp (Type v) X Y Z ≫ (fun X Y f => F.map f) X Z) (f, g) =
    (((fun X Y f => F.map f) X Y ⊗ (fun X Y f => F.map f) Y Z) ≫
        eComp (Type v) ((fun X => F.obj X) X) ((fun X => F.obj X) Y) ((fun X => F.obj X) Z))
      (f, g)
tactic: ext ⟨f, g⟩
state_before: case h.mk
V : Type v
inst✝² : Category.{w, v} V
inst✝¹ : MonoidalCategory V
C✝ : Type u₁
inst✝ : EnrichedCategory V C✝
C : Type u₁
𝒞 : EnrichedCategory (Type v) C
D : Type u₂
𝒟 : EnrichedCategory (Type v) D
F : C ⥤ D
X Y Z : C
f : EnrichedCategory.Hom X Y
g : EnrichedCategory.Hom Y Z
⊢ (eComp (Type v) X Y Z ≫ (fun X Y f => F.map f) X Z) (f, g) =
    (((fun X Y f => F.map f) X Y ⊗ (fun X Y f => F.map f) Y Z) ≫
        eComp (Type v) ((fun X => F.obj X) X) ((fun X => F.obj X) Y) ((fun X => F.obj X) Z))
      (f, g)
state_after: no goals
tactic: exact F.map_comp f g
Theorem: tendsto_atBot_ciSup
File: Mathlib/Topology/Order/MonotoneConvergence.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝³ : Preorder ι
inst✝² : TopologicalSpace α
inst✝¹ : ConditionallyCompleteLattice α
inst✝ : SupConvergenceClass α
f : ι → α
a : α
h_anti : Antitone f
hbdd : BddAbove (range f)
⊢ Tendsto f atBot (𝓝 (⨆ i, f i))
state_after: no goals
tactic: convert tendsto_atTop_ciSup h_anti.dual hbdd.dual using 1
Theorem: Int.card_fintype_Ioc_of_le
File: Mathlib/Data/Int/Interval.lean

Proof steps:
state_before: a b : ℤ
h : a ≤ b
⊢ ↑(Fintype.card ↑(Set.Ioc a b)) = b - a
state_after: no goals
tactic: rw [card_fintype_Ioc, toNat_sub_of_le h]
Theorem: Filter.frequently_iff_neBot
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
p : α → Prop
⊢ (∃ᶠ (x : α) in l, p x) ↔ (l ⊓ 𝓟 {x | p x}).NeBot
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
p : α → Prop
⊢ (∃ᶠ (x : α) in l, p x) ↔ {x | p x}ᶜ ∉ l
tactic: rw [neBot_iff, Ne, inf_principal_eq_bot]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
p : α → Prop
⊢ (∃ᶠ (x : α) in l, p x) ↔ {x | p x}ᶜ ∉ l
state_after: no goals
tactic: rfl
Theorem: RatFunc.liftOn_ofFractionRing_mk
File: Mathlib/FieldTheory/RatFunc/Defs.lean

Proof steps:
state_before: K : Type u
inst✝ : CommRing K
P : Sort v
n : K[X]
d : ↥K[X]⁰
f : K[X] → K[X] → P
H : ∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q'
⊢ { toFractionRing := Localization.mk n d }.liftOn f H = f n ↑d
state_after: K : Type u
inst✝ : CommRing K
P : Sort v
n : K[X]
d : ↥K[X]⁰
f : K[X] → K[X] → P
H : ∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q'
⊢ Localization.liftOn { toFractionRing := Localization.mk n d }.toFractionRing (fun p q => f p ↑q) ⋯ = f n ↑d
tactic: rw [RatFunc.liftOn]
state_before: K : Type u
inst✝ : CommRing K
P : Sort v
n : K[X]
d : ↥K[X]⁰
f : K[X] → K[X] → P
H : ∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q'
⊢ Localization.liftOn { toFractionRing := Localization.mk n d }.toFractionRing (fun p q => f p ↑q) ⋯ = f n ↑d
state_after: no goals
tactic: exact Localization.liftOn_mk _ _ _ _
Theorem: CategoryTheory.Pretriangulated.Triangle.eqToHom_hom₂
File: Mathlib/CategoryTheory/Triangulated/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A B : Triangle C
h : A = B
⊢ A.obj₂ = B.obj₂
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A : Triangle C
⊢ A.obj₂ = A.obj₂
tactic: subst h
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A : Triangle C
⊢ A.obj₂ = A.obj₂
state_after: no goals
tactic: rfl
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A B : Triangle C
h : A = B
⊢ (eqToHom h).hom₂ = eqToHom ⋯
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A : Triangle C
⊢ (eqToHom ⋯).hom₂ = eqToHom ⋯
tactic: subst h
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A : Triangle C
⊢ (eqToHom ⋯).hom₂ = eqToHom ⋯
state_after: no goals
tactic: rfl