1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Matrix.charpoly_reindex
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Basic.lean

tactic: unfold Matrix.charpoly
state_before: R : Type u_1
S : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
m : Type u_3
n : Type u_4
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Fintype m
inst✝ : Fintype n
M₁₁ : Matrix m m R
M₁₂ : Matrix m n R
M₂₁ : Matrix n m R
M₂₂ M✝ : Matrix n n R
i j : n
e : n ≃ m
M : Matrix n n R
⊢ ((reindex e e) M).charpoly = M.charpoly
state_after: R : Type u_1
S : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
m : Type u_3
n : Type u_4
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Fintype m
inst✝ : Fintype n
M₁₁ : Matrix m m R
M₁₂ : Matrix m n R
M₂₁ : Matrix n m R
M₂₂ M✝ : Matrix n n R
i j : n
e : n ≃ m
M : Matrix n n R
⊢ ((reindex e e) M).charmatrix.det = M.charmatrix.det

tactic: rw [charmatrix_reindex, Matrix.det_reindex_self]
state_before: R : Type u_1
S : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
m : Type u_3
n : Type u_4
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Fintype m
inst✝ : Fintype n
M₁₁ : Matrix m m R
M₁₂ : Matrix m n R
M₂₁ : Matrix n m R
M₂₂ M✝ : Matrix n n R
i j : n
e : n ≃ m
M : Matrix n n R
⊢ ((reindex e e) M).charmatrix.det = M.charmatrix.det
state_after: no goals
Theorem: HasSum.mul_left
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

tactic: simpa only using h.map (AddMonoidHom.mulLeft a₂) (continuous_const.mul continuous_id)
state_before: ι : Type u_1
κ : Type u_2
R : Type u_3
α : Type u_4
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSemiring α
f g : ι → α
a a₁ a₂✝ a₂ : α
h : HasSum f a₁
⊢ HasSum (fun i => a₂ * f i) (a₂ * a₁)
state_after: no goals
Theorem: LocallyFinite.iInter_compl_mem_nhds
File: Mathlib/Topology/LocallyFinite.lean

tactic: refine IsOpen.mem_nhds ?_ (mem_iInter₂.2 fun i => id)
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
hf : LocallyFinite f
hc : ∀ (i : ι), IsClosed (f i)
x : X
⊢ ⋂ i, ⋂ (_ : x ∉ f i), (f i)ᶜ ∈ 𝓝 x
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
hf : LocallyFinite f
hc : ∀ (i : ι), IsClosed (f i)
x : X
⊢ IsOpen (⋂ i, ⋂ (_ : x ∉ f i), (f i)ᶜ)

tactic: suffices IsClosed (⋃ i : { i // x ∉ f i }, f i) by
  rwa [← isOpen_compl_iff, compl_iUnion, iInter_subtype] at this
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
hf : LocallyFinite f
hc : ∀ (i : ι), IsClosed (f i)
x : X
⊢ IsOpen (⋂ i, ⋂ (_ : x ∉ f i), (f i)ᶜ)
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
hf : LocallyFinite f
hc : ∀ (i : ι), IsClosed (f i)
x : X
⊢ IsClosed (⋃ i, f ↑i)

tactic: exact (hf.comp_injective Subtype.val_injective).isClosed_iUnion fun i => hc _
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
hf : LocallyFinite f
hc : ∀ (i : ι), IsClosed (f i)
x : X
⊢ IsClosed (⋃ i, f ↑i)
state_after: no goals

tactic: rwa [← isOpen_compl_iff, compl_iUnion, iInter_subtype] at this
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
hf : LocallyFinite f
hc : ∀ (i : ι), IsClosed (f i)
x : X
this : IsClosed (⋃ i, f ↑i)
⊢ IsOpen (⋂ i, ⋂ (_ : x ∉ f i), (f i)ᶜ)
state_after: no goals
Theorem: smul_eq_zero_iff_left
File: Mathlib/Algebra/Module/Defs.lean

tactic: simp [hx]
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
Theorem: Int.Ioc_filter_dvd_eq
File: Mathlib/Data/Int/CardIntervalMod.lean

tactic: ext x
state_before: a b r : ℤ
hr : 0 < r
⊢ filter (fun x => r ∣ x) (Ioc a b) = map { toFun := fun x => x * r, inj' := ⋯ } (Ioc ⌊↑a / ↑r⌋ ⌊↑b / ↑r⌋)
state_after: case a
a b r : ℤ
hr : 0 < r
x : ℤ
⊢ x ∈ filter (fun x => r ∣ x) (Ioc a b) ↔ x ∈ map { toFun := fun x => x * r, inj' := ⋯ } (Ioc ⌊↑a / ↑r⌋ ⌊↑b / ↑r⌋)

tactic: simp only [mem_map, mem_filter, mem_Ioc, floor_lt, le_floor, div_lt_iff, le_div_iff,
  dvd_iff_exists_eq_mul_left, cast_pos.2 hr, ← cast_mul, cast_lt, cast_le]
state_before: case a
a b r : ℤ
hr : 0 < r
x : ℤ
⊢ x ∈ filter (fun x => r ∣ x) (Ioc a b) ↔ x ∈ map { toFun := fun x => x * r, inj' := ⋯ } (Ioc ⌊↑a / ↑r⌋ ⌊↑b / ↑r⌋)
state_after: case a
a b r : ℤ
hr : 0 < r
x : ℤ
⊢ ((a < x ∧ x ≤ b) ∧ ∃ c, x = c * r) ↔
    ∃ a_1, (a < a_1 * r ∧ a_1 * r ≤ b) ∧ { toFun := fun x => x * r, inj' := ⋯ } a_1 = x

tactic: aesop
state_before: case a
a b r : ℤ
hr : 0 < r
x : ℤ
⊢ ((a < x ∧ x ≤ b) ∧ ∃ c, x = c * r) ↔
    ∃ a_1, (a < a_1 * r ∧ a_1 * r ≤ b) ∧ { toFun := fun x => x * r, inj' := ⋯ } a_1 = x
state_after: no goals
Theorem: Zsqrtd.nonneg_iff_zero_le
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: simp
state_before: d : ℕ
a : ℤ√↑d
⊢ a.Nonneg ↔ (a - 0).Nonneg
state_after: no goals
Theorem: Nat.size_shiftLeft
File: Mathlib/Data/Nat/Size.lean

tactic: simp only [size_shiftLeft' (shiftLeft'_ne_zero_left _ h _), ← shiftLeft'_false]
state_before: m : ℕ
h : m ≠ 0
n : ℕ
⊢ (m <<< n).size = m.size + n
state_after: no goals
Theorem: Real.sin_pi_div_four
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: trans sin (π / 2 ^ 2)
state_before: x : ℝ
⊢ sin (π / 4) = √2 / 2
state_after: x : ℝ
⊢ sin (π / 4) = sin (π / 2 ^ 2)

x : ℝ
⊢ sin (π / 2 ^ 2) = √2 / 2

tactic: congr
state_before: x : ℝ
⊢ sin (π / 4) = sin (π / 2 ^ 2)
state_after: case e_x.e_a
x : ℝ
⊢ 4 = 2 ^ 2

tactic: norm_num
state_before: case e_x.e_a
x : ℝ
⊢ 4 = 2 ^ 2
state_after: no goals

tactic: simp
state_before: x : ℝ
⊢ sin (π / 2 ^ 2) = √2 / 2
state_after: no goals
Theorem: Set.covBy_iff_exists_sdiff_singleton
File: Mathlib/Order/Cover.lean

tactic: rintro ⟨a, ha, rfl⟩
state_before: α : Type u_1
β : Type u_2
s t : Set α
a : α
⊢ (∃ a ∈ t, t \ {a} = s) → s ⋖ t
state_after: case intro.intro
α : Type u_1
β : Type u_2
t : Set α
a✝ a : α
ha : a ∈ t
⊢ t \ {a} ⋖ t

tactic: exact sdiff_singleton_covBy ha
state_before: case intro.intro
α : Type u_1
β : Type u_2
t : Set α
a✝ a : α
ha : a ∈ t
⊢ t \ {a} ⋖ t
state_after: no goals
Theorem: List.forall₂_zip
File: Mathlib/Data/List/Forall2.lean

tactic: rw [zip, zipWith, mem_cons] at hx
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
x : α
y : β
hx : (x, y) ∈ (a✝ :: l₁✝).zip (b✝ :: l₂✝)
⊢ R x y
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
x : α
y : β
hx : (x, y) = (a✝, b✝) ∨ (x, y) ∈ zipWith Prod.mk l₁✝ l₂✝
⊢ R x y

tactic: match hx with
| Or.inl rfl => exact h₁
| Or.inr h₃ => exact forall₂_zip h₂ h₃
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
x : α
y : β
hx : (x, y) = (a✝, b✝) ∨ (x, y) ∈ zipWith Prod.mk l₁✝ l₂✝
⊢ R x y
state_after: no goals

tactic: exact h₁
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₂ : Forall₂ R l₁✝ l₂✝
x : α
y : β
hx : (x, y) = (a✝, b✝) ∨ (x, y) ∈ zipWith Prod.mk l₁✝ l₂✝
h₁ : R x y
⊢ R x y
state_after: no goals

tactic: exact forall₂_zip h₂ h₃
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₂ : Forall₂ R l₁✝ l₂✝
x : α
y : β
hx : (x, y) = (a✝, b✝) ∨ (x, y) ∈ zipWith Prod.mk l₁✝ l₂✝
x✝¹ : β
x✝ : α
h₃ : (x, y) ∈ zipWith Prod.mk l₁✝ l₂✝
h₁ : R x✝ x✝¹
⊢ R x y
state_after: no goals
Theorem: GeneralizedContinuedFraction.squashGCF_eq_self_of_terminated
File: Mathlib/Algebra/ContinuedFractions/ConvergentsEquiv.lean

tactic: cases n with
| zero =>
  change g.s.get? 0 = none at terminated_at_n
  simp only [convergents', squashGCF, convergents'Aux, terminated_at_n]
| succ =>
  cases g
  simp only [squashGCF, mk.injEq, true_and]
  exact squashSeq_eq_self_of_terminated terminated_at_n
state_before: K : Type u_1
n : ℕ
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
terminated_at_n : g.TerminatedAt n
⊢ g.squashGCF n = g
state_after: no goals

tactic: change g.s.get? 0 = none at terminated_at_n
state_before: case zero
K : Type u_1
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
terminated_at_n : g.TerminatedAt 0
⊢ g.squashGCF 0 = g
state_after: case zero
K : Type u_1
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
terminated_at_n : g.s.get? 0 = none
⊢ g.squashGCF 0 = g

tactic: simp only [convergents', squashGCF, convergents'Aux, terminated_at_n]
state_before: case zero
K : Type u_1
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
terminated_at_n : g.s.get? 0 = none
⊢ g.squashGCF 0 = g
state_after: no goals

tactic: cases g
state_before: case succ
K : Type u_1
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
n✝ : ℕ
terminated_at_n : g.TerminatedAt (n✝ + 1)
⊢ g.squashGCF (n✝ + 1) = g
state_after: case succ.mk
K : Type u_1
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
n✝ : ℕ
h✝ : K
s✝ : Stream'.Seq (Pair K)
terminated_at_n : { h := h✝, s := s✝ }.TerminatedAt (n✝ + 1)
⊢ { h := h✝, s := s✝ }.squashGCF (n✝ + 1) = { h := h✝, s := s✝ }

tactic: simp only [squashGCF, mk.injEq, true_and]
state_before: case succ.mk
K : Type u_1
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
n✝ : ℕ
h✝ : K
s✝ : Stream'.Seq (Pair K)
terminated_at_n : { h := h✝, s := s✝ }.TerminatedAt (n✝ + 1)
⊢ { h := h✝, s := s✝ }.squashGCF (n✝ + 1) = { h := h✝, s := s✝ }
state_after: case succ.mk
K : Type u_1
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
n✝ : ℕ
h✝ : K
s✝ : Stream'.Seq (Pair K)
terminated_at_n : { h := h✝, s := s✝ }.TerminatedAt (n✝ + 1)
⊢ squashSeq s✝ n✝ = s✝

tactic: exact squashSeq_eq_self_of_terminated terminated_at_n
state_before: case succ.mk
K : Type u_1
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
n✝ : ℕ
h✝ : K
s✝ : Stream'.Seq (Pair K)
terminated_at_n : { h := h✝, s := s✝ }.TerminatedAt (n✝ + 1)
⊢ squashSeq s✝ n✝ = s✝
state_after: no goals
Theorem: ArithmeticFunction.cardFactors_one
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: simp [cardFactors_apply]
state_before: R : Type u_1
⊢ Ω 1 = 0
state_after: no goals
Theorem: CategoryTheory.Subobject.inf_eq_map_pullback'
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: induction' f₂ using Quotient.inductionOn' with f₂
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A : C
f₁ : MonoOver A
f₂ : Subobject A
⊢ (inf.obj (Quotient.mk'' f₁)).obj f₂ = (map f₁.arrow).obj ((pullback f₁.arrow).obj f₂)
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A : C
f₁ f₂ : MonoOver A
⊢ (inf.obj (Quotient.mk'' f₁)).obj (Quotient.mk'' f₂) = (map f₁.arrow).obj ((pullback f₁.arrow).obj (Quotient.mk'' f₂))

tactic: rfl
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A : C
f₁ f₂ : MonoOver A
⊢ (inf.obj (Quotient.mk'' f₁)).obj (Quotient.mk'' f₂) = (map f₁.arrow).obj ((pullback f₁.arrow).obj (Quotient.mk'' f₂))
state_after: no goals
Theorem: OrderIso.mulRight_symm
File: Mathlib/Algebra/Order/Group/OrderIso.lean

tactic: ext x
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c d a : α
⊢ (mulRight a).symm = mulRight a⁻¹
state_after: case h.h
α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c d a x : α
⊢ (mulRight a).symm x = (mulRight a⁻¹) x

tactic: rfl
state_before: case h.h
α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c d a x : α
⊢ (mulRight a).symm x = (mulRight a⁻¹) x
state_after: no goals
Theorem: GaloisInsertion.isCoatom_iff
File: Mathlib/Order/Atoms.lean

tactic: refine ⟨fun hb => gi.isCoatom_of_image hb, fun hb => ?_⟩
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderTop α
inst✝¹ : IsCoatomic α
inst✝ : OrderTop β
l : α → β
u : β → α
gi : GaloisInsertion l u
h_coatom : ∀ (a : α), IsCoatom a → u (l a) = a
b : β
⊢ IsCoatom (u b) ↔ IsCoatom b
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderTop α
inst✝¹ : IsCoatomic α
inst✝ : OrderTop β
l : α → β
u : β → α
gi : GaloisInsertion l u
h_coatom : ∀ (a : α), IsCoatom a → u (l a) = a
b : β
hb : IsCoatom b
⊢ IsCoatom (u b)

tactic: obtain ⟨a, ha, hab⟩ :=
  (eq_top_or_exists_le_coatom (u b)).resolve_left fun h =>
    hb.1 <| (gi.gc.u_top ▸ gi.l_u_eq ⊤ : l ⊤ = ⊤) ▸ gi.l_u_eq b ▸ congr_arg l h
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderTop α
inst✝¹ : IsCoatomic α
inst✝ : OrderTop β
l : α → β
u : β → α
gi : GaloisInsertion l u
h_coatom : ∀ (a : α), IsCoatom a → u (l a) = a
b : β
hb : IsCoatom b
⊢ IsCoatom (u b)
state_after: case intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderTop α
inst✝¹ : IsCoatomic α
inst✝ : OrderTop β
l : α → β
u : β → α
gi : GaloisInsertion l u
h_coatom : ∀ (a : α), IsCoatom a → u (l a) = a
b : β
hb : IsCoatom b
a : α
ha : IsCoatom a
hab : u b ≤ a
⊢ IsCoatom (u b)

tactic: have : l a = b :=
  (hb.le_iff.mp (gi.l_u_eq b ▸ gi.gc.monotone_l hab : b ≤ l a)).resolve_left fun hla =>
    ha.1 (gi.gc.u_top ▸ h_coatom a ha ▸ congr_arg u hla)
state_before: case intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderTop α
inst✝¹ : IsCoatomic α
inst✝ : OrderTop β
l : α → β
u : β → α
gi : GaloisInsertion l u
h_coatom : ∀ (a : α), IsCoatom a → u (l a) = a
b : β
hb : IsCoatom b
a : α
ha : IsCoatom a
hab : u b ≤ a
⊢ IsCoatom (u b)
state_after: case intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderTop α
inst✝¹ : IsCoatomic α
inst✝ : OrderTop β
l : α → β
u : β → α
gi : GaloisInsertion l u
h_coatom : ∀ (a : α), IsCoatom a → u (l a) = a
b : β
hb : IsCoatom b
a : α
ha : IsCoatom a
hab : u b ≤ a
this : l a = b
⊢ IsCoatom (u b)

tactic: exact this ▸ (h_coatom a ha).symm ▸ ha
state_before: case intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderTop α
inst✝¹ : IsCoatomic α
inst✝ : OrderTop β
l : α → β
u : β → α
gi : GaloisInsertion l u
h_coatom : ∀ (a : α), IsCoatom a → u (l a) = a
b : β
hb : IsCoatom b
a : α
ha : IsCoatom a
hab : u b ≤ a
this : l a = b
⊢ IsCoatom (u b)
state_after: no goals
Theorem: Finset.filter_le_le_eq_Icc
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: ext
state_before: ι : Type u_1
α : Type u_2
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a ≤ j ∧ j ≤ b
⊢ filter (fun j => a ≤ j ∧ j ≤ b) univ = Icc a b
state_after: case a
ι : Type u_1
α : Type u_2
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a ≤ j ∧ j ≤ b
a✝ : α
⊢ a✝ ∈ filter (fun j => a ≤ j ∧ j ≤ b) univ ↔ a✝ ∈ Icc a b

tactic: simp
state_before: case a
ι : Type u_1
α : Type u_2
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a ≤ j ∧ j ≤ b
a✝ : α
⊢ a✝ ∈ filter (fun j => a ≤ j ∧ j ≤ b) univ ↔ a✝ ∈ Icc a b
state_after: no goals
Theorem: IsSelfAdjoint.smul
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [isSelfAdjoint_iff, star_smul, hr.star_eq, hx.star_eq]
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : Star R
inst✝³ : AddMonoid A
inst✝² : StarAddMonoid A
inst✝¹ : SMul R A
inst✝ : StarModule R A
r : R
hr : IsSelfAdjoint r
x : A
hx : IsSelfAdjoint x
⊢ IsSelfAdjoint (r • x)
state_after: no goals
Theorem: mem_nhdsWithin_subtype
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [nhdsWithin, nhds_subtype, principal_subtype, ← comap_inf, ← nhdsWithin]
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 : Set α
a : { x // x ∈ s }
t u : Set { x // x ∈ s }
⊢ t ∈ 𝓝[u] a ↔ t ∈ comap Subtype.val (𝓝[Subtype.val '' u] ↑a)
state_after: no goals
Theorem: Turing.ToPartrec.Code.tail_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [eval]
state_before: ⊢ tail.eval = fun v => pure v.tail
state_after: no goals
Theorem: Cardinal.nat_lt_lift_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_natCast.{v,u}, lift_lt]
state_before: α β : Type u
n : ℕ
a : Cardinal.{u}
⊢ ↑n < lift.{v, u} a ↔ ↑n < a
state_after: no goals
Theorem: CategoryTheory.ComposableArrows.homMk₃_app_two
File: Mathlib/CategoryTheory/ComposableArrows.lean

tactic: valid
state_before: C : Type u_1
inst✝ : Category.{?u.247637, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 3
app₀ : f.obj' 0 ⋯ ⟶ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ⟶ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ⟶ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ⟶ g.obj' 3 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁ = app₀ ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂ = app₁ ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃ = app₂ ≫ g.map' 2 3 ⋯ ⋯
⊢ 2 < 3 + 1
state_after: no goals
Theorem: fibRec_charPoly_eq
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: rw [fibRec, LinearRecurrence.charPoly]
state_before: α : Type u_1
inst✝¹ : CommSemiring α
β : Type u_2
inst✝ : CommRing β
⊢ fibRec.charPoly = X ^ 2 - (X + 1)
state_after: α : Type u_1
inst✝¹ : CommSemiring α
β : Type u_2
inst✝ : CommRing β
⊢ (monomial { order := 2, coeffs := ![1, 1] }.order) 1 -
      ∑ i : Fin { order := 2, coeffs := ![1, 1] }.order, (monomial ↑i) ({ order := 2, coeffs := ![1, 1] }.coeffs i) =
    X ^ 2 - (X + 1)

tactic: simp [Finset.sum_fin_eq_sum_range, Finset.sum_range_succ', ← smul_X_eq_monomial]
state_before: α : Type u_1
inst✝¹ : CommSemiring α
β : Type u_2
inst✝ : CommRing β
⊢ (monomial { order := 2, coeffs := ![1, 1] }.order) 1 -
      ∑ i : Fin { order := 2, coeffs := ![1, 1] }.order, (monomial ↑i) ({ order := 2, coeffs := ![1, 1] }.coeffs i) =
    X ^ 2 - (X + 1)
state_after: no goals
Theorem: Nat.Coprime.orderOf_pow
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: by_cases hg : IsOfFinOrder y
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : (orderOf y).Coprime m
⊢ orderOf (y ^ m) = orderOf y
state_after: case pos
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : (orderOf y).Coprime m
hg : IsOfFinOrder y
⊢ orderOf (y ^ m) = orderOf y

case neg
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : (orderOf y).Coprime m
hg : ¬IsOfFinOrder y
⊢ orderOf (y ^ m) = orderOf y

tactic: rw [hg.orderOf_pow y m , h.gcd_eq_one, Nat.div_one]
state_before: case pos
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : (orderOf y).Coprime m
hg : IsOfFinOrder y
⊢ orderOf (y ^ m) = orderOf y
state_after: no goals

tactic: rw [m.coprime_zero_left.1 (orderOf_eq_zero hg ▸ h), pow_one]
state_before: case neg
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : (orderOf y).Coprime m
hg : ¬IsOfFinOrder y
⊢ orderOf (y ^ m) = orderOf y
state_after: no goals
Theorem: Matrix.det_mul_left_comm
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

tactic: rw [← Matrix.mul_assoc, ← Matrix.mul_assoc, det_mul, det_mul_comm M N, ← det_mul]
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N P : Matrix m m R
⊢ (M * (N * P)).det = (N * (M * P)).det
state_after: no goals
Theorem: List.get_ofFn
File: Mathlib/Data/List/OfFn.lean

tactic: simp
state_before: α : Type u
n : ℕ
f : Fin n → α
i : Fin (ofFn f).length
⊢ (ofFn f).length = n
state_after: no goals

tactic: simp
state_before: α : Type u
n : ℕ
f : Fin n → α
i : Fin (ofFn f).length
⊢ (ofFn f).get i = f (Fin.cast ⋯ i)
state_after: α : Type u
n : ℕ
f : Fin n → α
i : Fin (ofFn f).length
⊢ f ⟨↑i, ⋯⟩ = f (Fin.cast ⋯ i)

tactic: congr
state_before: α : Type u
n : ℕ
f : Fin n → α
i : Fin (ofFn f).length
⊢ f ⟨↑i, ⋯⟩ = f (Fin.cast ⋯ i)
state_after: no goals
Theorem: MeasureTheory.pdf.integral_pdf_smul
File: Mathlib/Probability/Density.lean

tactic: rw [← integral_map (HasPDF.aemeasurable X ℙ μ) (hf.mono_ac HasPDF.absolutelyContinuous),
  map_eq_withDensity_pdf X ℙ μ, pdf_def, integral_rnDeriv_smul HasPDF.absolutelyContinuous,
  withDensity_rnDeriv_eq _ _ HasPDF.absolutelyContinuous]
state_before: Ω : Type u_1
E : Type u_2
inst✝⁵ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
F : Type u_3
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
inst✝¹ : IsFiniteMeasure ℙ
X : Ω → E
inst✝ : HasPDF X ℙ μ
f : E → F
hf : AEStronglyMeasurable f μ
⊢ ∫ (x : E), (pdf X ℙ μ x).toReal • f x ∂μ = ∫ (x : Ω), f (X x) ∂ℙ
state_after: no goals
Theorem: Mathlib.Tactic.Ring.one_mul
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp [Nat.rawCast]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
⊢ Nat.rawCast 1 * a = a
state_after: no goals
Theorem: Real.le_rpow_of_log_le
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: obtain hx | rfl := hx.lt_or_eq
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 < y
h : log x ≤ z * log y
⊢ x ≤ y ^ z
state_after: case inl
x y z : ℝ
n : ℕ
hx✝ : 0 ≤ x
hy : 0 < y
h : log x ≤ z * log y
hx : 0 < x
⊢ x ≤ y ^ z

case inr
y z : ℝ
n : ℕ
hy : 0 < y
hx : 0 ≤ 0
h : log 0 ≤ z * log y
⊢ 0 ≤ y ^ z

tactic: exact (Real.rpow_pos_of_pos hy z).le
state_before: case inr
y z : ℝ
n : ℕ
hy : 0 < y
hx : 0 ≤ 0
h : log 0 ≤ z * log y
⊢ 0 ≤ y ^ z
state_after: no goals

tactic: exact (le_rpow_iff_log_le hx hy).2 h
state_before: case inl
x y z : ℝ
n : ℕ
hx✝ : 0 ≤ x
hy : 0 < y
h : log x ≤ z * log y
hx : 0 < x
⊢ x ≤ y ^ z
state_after: no goals
Theorem: Finmap.insert_insert
File: Mathlib/Data/Finmap.lean

tactic: simp only [insert_toFinmap, AList.insert_insert]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b b' : β a
s✝ : Finmap β
s : AList β
⊢ insert a b' (insert a b ⟦s⟧) = insert a b' ⟦s⟧
state_after: no goals
Theorem: Finsupp.mapDomain_congr
File: Mathlib/Data/Finsupp/Basic.lean

tactic: simp only [h _ H]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H✝ : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f g : α → β
h : ∀ x ∈ v.support, f x = g x
x✝ : α
H : x✝ ∈ v.support
⊢ (fun a => single (f a)) x✝ (v x✝) = (fun a => single (g a)) x✝ (v x✝)
state_after: no goals
Theorem: Part.toOption_eq_none
File: Mathlib/Data/Part.lean

tactic: by_cases h : o.Dom <;> simp [h, toOption]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
inst✝ : Decidable o.Dom
⊢ o.toOption = none ↔ ¬o.Dom
state_after: no goals