1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: FirstOrder.Language.LHom.id_onTerm
File: Mathlib/ModelTheory/Syntax.lean

tactic: ext t
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
⊢ (LHom.id L).onTerm = id
state_after: case h
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
t : L.Term α
⊢ (LHom.id L).onTerm t = id t

tactic: induction' t with _ _ _ _ ih
state_before: case h
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
t : L.Term α
⊢ (LHom.id L).onTerm t = id t
state_after: case h.var
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
a✝ : α
⊢ (LHom.id L).onTerm (var a✝) = id (var a✝)

case h.func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
l✝ : ℕ
_f✝ : L.Functions l✝
_ts✝ : Fin l✝ → L.Term α
ih : ∀ (a : Fin l✝), (LHom.id L).onTerm (_ts✝ a) = id (_ts✝ a)
⊢ (LHom.id L).onTerm (func _f✝ _ts✝) = id (func _f✝ _ts✝)

tactic: rfl
state_before: case h.var
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
a✝ : α
⊢ (LHom.id L).onTerm (var a✝) = id (var a✝)
state_after: no goals

tactic: simp_rw [onTerm, ih]
state_before: case h.func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
l✝ : ℕ
_f✝ : L.Functions l✝
_ts✝ : Fin l✝ → L.Term α
ih : ∀ (a : Fin l✝), (LHom.id L).onTerm (_ts✝ a) = id (_ts✝ a)
⊢ (LHom.id L).onTerm (func _f✝ _ts✝) = id (func _f✝ _ts✝)
state_after: case h.func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
l✝ : ℕ
_f✝ : L.Functions l✝
_ts✝ : Fin l✝ → L.Term α
ih : ∀ (a : Fin l✝), (LHom.id L).onTerm (_ts✝ a) = id (_ts✝ a)
⊢ (func ((LHom.id L).onFunction _f✝) fun i => id (_ts✝ i)) = id (func _f✝ _ts✝)

tactic: rfl
state_before: case h.func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
l✝ : ℕ
_f✝ : L.Functions l✝
_ts✝ : Fin l✝ → L.Term α
ih : ∀ (a : Fin l✝), (LHom.id L).onTerm (_ts✝ a) = id (_ts✝ a)
⊢ (func ((LHom.id L).onFunction _f✝) fun i => id (_ts✝ i)) = id (func _f✝ _ts✝)
state_after: no goals
Theorem: Computable.option_getD
File: Mathlib/Computability/Partrec.lean

tactic: cases f a <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
g : α → β
hf : Computable f
hg : Computable g
a : α
⊢ (Option.casesOn (f a) (g a) fun b => b) = (f a).getD (g a)
state_after: no goals
Theorem: Polynomial.mem_nonZeroDivisors_of_leadingCoeff
File: Mathlib/Algebra/Polynomial/RingDivision.lean

tactic: refine mem_nonZeroDivisors_iff.2 fun x hx ↦ leadingCoeff_eq_zero.1 ?_
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
h : p.leadingCoeff ∈ R⁰
⊢ p ∈ R[X]⁰
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
h : p.leadingCoeff ∈ R⁰
x : R[X]
hx : x * p = 0
⊢ x.leadingCoeff = 0

tactic: by_contra hx'
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
h : p.leadingCoeff ∈ R⁰
x : R[X]
hx : x * p = 0
⊢ x.leadingCoeff = 0
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
h : p.leadingCoeff ∈ R⁰
x : R[X]
hx : x * p = 0
hx' : ¬x.leadingCoeff = 0
⊢ False

tactic: rw [← mul_right_mem_nonZeroDivisors_eq_zero_iff h] at hx'
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
h : p.leadingCoeff ∈ R⁰
x : R[X]
hx : x * p = 0
hx' : ¬x.leadingCoeff = 0
⊢ False
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
h : p.leadingCoeff ∈ R⁰
x : R[X]
hx : x * p = 0
hx' : ¬x.leadingCoeff * p.leadingCoeff = 0
⊢ False

tactic: simp only [← leadingCoeff_mul' hx', hx, leadingCoeff_zero, not_true] at hx'
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
h : p.leadingCoeff ∈ R⁰
x : R[X]
hx : x * p = 0
hx' : ¬x.leadingCoeff * p.leadingCoeff = 0
⊢ False
state_after: no goals
Theorem: Matrix.toBlock_diagonal_self
File: Mathlib/Data/Matrix/Block.lean

tactic: ext i j
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p✝ : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝² : DecidableEq l
inst✝¹ : DecidableEq m
inst✝ : Zero α
d : m → α
p : m → Prop
⊢ (diagonal d).toBlock p p = diagonal fun i => d ↑i
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p✝ : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝² : DecidableEq l
inst✝¹ : DecidableEq m
inst✝ : Zero α
d : m → α
p : m → Prop
i j : { a // p a }
⊢ (diagonal d).toBlock p p i j = diagonal (fun i => d ↑i) i j

tactic: by_cases h : i = j
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p✝ : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝² : DecidableEq l
inst✝¹ : DecidableEq m
inst✝ : Zero α
d : m → α
p : m → Prop
i j : { a // p a }
⊢ (diagonal d).toBlock p p i j = diagonal (fun i => d ↑i) i j
state_after: case pos
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p✝ : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝² : DecidableEq l
inst✝¹ : DecidableEq m
inst✝ : Zero α
d : m → α
p : m → Prop
i j : { a // p a }
h : i = j
⊢ (diagonal d).toBlock p p i j = diagonal (fun i => d ↑i) i j

case neg
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p✝ : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝² : DecidableEq l
inst✝¹ : DecidableEq m
inst✝ : Zero α
d : m → α
p : m → Prop
i j : { a // p a }
h : ¬i = j
⊢ (diagonal d).toBlock p p i j = diagonal (fun i => d ↑i) i j

tactic: simp [h]
state_before: case pos
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p✝ : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝² : DecidableEq l
inst✝¹ : DecidableEq m
inst✝ : Zero α
d : m → α
p : m → Prop
i j : { a // p a }
h : i = j
⊢ (diagonal d).toBlock p p i j = diagonal (fun i => d ↑i) i j
state_after: no goals

tactic: simp [One.one, h, Subtype.val_injective.ne h]
state_before: case neg
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p✝ : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝² : DecidableEq l
inst✝¹ : DecidableEq m
inst✝ : Zero α
d : m → α
p : m → Prop
i j : { a // p a }
h : ¬i = j
⊢ (diagonal d).toBlock p p i j = diagonal (fun i => d ↑i) i j
state_after: no goals
Theorem: Submodule.annihilator_quotient
File: Mathlib/RingTheory/Ideal/Colon.lean

tactic: simp_rw [SetLike.ext_iff, Module.mem_annihilator, colon, mem_annihilator, map_top,
  LinearMap.range_eq_top.mpr (mkQ_surjective N), mem_top, forall_true_left, forall_const]
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
F : Type u_4
G : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N✝ N₁ N₂ P P₁ P₂ N : Submodule R M
⊢ Module.annihilator R (M ⧸ N) = N.colon ⊤
state_after: no goals
Theorem: LinearMap.baseChange_smul
File: Mathlib/RingTheory/TensorProduct/Basic.lean

tactic: ext
state_before: R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
inst✝¹⁰ : CommSemiring R
inst✝⁹ : Semiring A
inst✝⁸ : Algebra R A
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R B
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
r : R
f g : M →ₗ[R] N
⊢ baseChange A (r • f) = r • baseChange A f
state_after: case a.h.h
R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
inst✝¹⁰ : CommSemiring R
inst✝⁹ : Semiring A
inst✝⁸ : Algebra R A
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R B
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
r : R
f g : M →ₗ[R] N
x✝ : M
⊢ ((AlgebraTensorModule.curry (baseChange A (r • f))) 1) x✝ = ((AlgebraTensorModule.curry (r • baseChange A f)) 1) x✝

tactic: simp [baseChange_tmul]
state_before: case a.h.h
R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
inst✝¹⁰ : CommSemiring R
inst✝⁹ : Semiring A
inst✝⁸ : Algebra R A
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R B
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
r : R
f g : M →ₗ[R] N
x✝ : M
⊢ ((AlgebraTensorModule.curry (baseChange A (r • f))) 1) x✝ = ((AlgebraTensorModule.curry (r • baseChange A f)) 1) x✝
state_after: no goals
Theorem: Subgroup.subgroupOf_map_subtype
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: refine Subtype.image_preimage_coe _ _ |>.trans ?_
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
H✝ K✝ : Subgroup G
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
H K : Subgroup G
⊢ ↑(map K.subtype (H.subgroupOf K)) = ↑(H ⊓ K)
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
H✝ K✝ : Subgroup G
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
H K : Subgroup G
⊢ ↑K ∩ H.toSubsemigroup.1 = ↑(H ⊓ K)

tactic: apply Set.inter_comm
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
H✝ K✝ : Subgroup G
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
H K : Subgroup G
⊢ ↑K ∩ H.toSubsemigroup.1 = ↑(H ⊓ K)
state_after: no goals
Theorem: ENNReal.mul_iInf_of_ne
File: Mathlib/Data/ENNReal/Real.lean

tactic: simpa only [mul_comm] using iInf_mul_of_ne h0 h
state_before: ι✝ : Sort u_1
f✝ g : ι✝ → ℝ≥0∞
a b c d : ℝ≥0∞
r p q : ℝ≥0
ι : Sort u_2
f : ι → ℝ≥0∞
x : ℝ≥0∞
h0 : x ≠ 0
h : x ≠ ⊤
⊢ x * iInf f = ⨅ i, x * f i
state_after: no goals
Theorem: CategoryTheory.Iso.comp_hom_eq_id
File: Mathlib/CategoryTheory/Iso.lean

tactic: rw [← eq_comp_inv, id_comp]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
α : X ≅ Y
f : Y ⟶ X
⊢ f ≫ α.hom = 𝟙 Y ↔ f = α.inv
state_after: no goals
Theorem: Polynomial.support_add
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: simpa [support] using Finsupp.support_add
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ (p + q).support ⊆ p.support ∪ q.support
state_after: no goals
Theorem: Ordnode.dual_balance'
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: simp [balance', add_comm]
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
⊢ (l.balance' x r).dual = r.dual.balance' x l.dual
state_after: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
⊢ (if l.size + r.size ≤ 1 then l.node' x r
      else
        if delta * l.size < r.size then l.rotateL x r
        else if delta * r.size < l.size then l.rotateR x r else l.node' x r).dual =
    if l.size + r.size ≤ 1 then r.dual.node' x l.dual
    else
      if delta * r.size < l.size then r.dual.rotateL x l.dual
      else if delta * l.size < r.size then r.dual.rotateR x l.dual else r.dual.node' x l.dual

tactic: split_ifs with h h_1 h_2 <;>
simp [dual_node', dual_rotateL, dual_rotateR, add_comm]
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
⊢ (if l.size + r.size ≤ 1 then l.node' x r
      else
        if delta * l.size < r.size then l.rotateL x r
        else if delta * r.size < l.size then l.rotateR x r else l.node' x r).dual =
    if l.size + r.size ≤ 1 then r.dual.node' x l.dual
    else
      if delta * r.size < l.size then r.dual.rotateL x l.dual
      else if delta * l.size < r.size then r.dual.rotateR x l.dual else r.dual.node' x l.dual
state_after: case pos
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
h : ¬l.size + r.size ≤ 1
h_1 : delta * l.size < r.size
h_2 : delta * r.size < l.size
⊢ r.dual.rotateR x l.dual = r.dual.rotateL x l.dual

tactic: cases delta_lt_false h_1 h_2
state_before: case pos
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
h : ¬l.size + r.size ≤ 1
h_1 : delta * l.size < r.size
h_2 : delta * r.size < l.size
⊢ r.dual.rotateR x l.dual = r.dual.rotateL x l.dual
state_after: no goals
Theorem: Lists.Equiv.symm
File: Mathlib/SetTheory/Lists.lean

tactic: cases' h with _ _ _ h₁ h₂ <;> [rfl; exact Equiv.antisymm h₂ h₁]
state_before: α : Type u_1
l₁ l₂ : Lists α
h : l₁ ~ l₂
⊢ l₂ ~ l₁
state_after: no goals
Theorem: Batteries.RBNode.max?_mem
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: simpa using min?_mem ((min?_reverse _).trans h)
state_before: α : Type u_1
a : α
t : RBNode α
h : t.max? = some a
⊢ a ∈ t
state_after: no goals
Theorem: IsCompact.inter_iInter_nonempty
File: Mathlib/Topology/Compactness/Compact.lean

tactic: contrapose! hst
state_before: X : Type u
Y : Type v
ι✝ : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
ι : Type v
hs : IsCompact s
t : ι → Set X
htc : ∀ (i : ι), IsClosed (t i)
hst : ∀ (u : Finset ι), (s ∩ ⋂ i ∈ u, t i).Nonempty
⊢ (s ∩ ⋂ i, t i).Nonempty
state_after: X : Type u
Y : Type v
ι✝ : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
ι : Type v
hs : IsCompact s
t : ι → Set X
htc : ∀ (i : ι), IsClosed (t i)
hst : s ∩ ⋂ i, t i = ∅
⊢ ∃ u, s ∩ ⋂ i ∈ u, t i = ∅

tactic: exact hs.elim_finite_subfamily_closed t htc hst
state_before: X : Type u
Y : Type v
ι✝ : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
ι : Type v
hs : IsCompact s
t : ι → Set X
htc : ∀ (i : ι), IsClosed (t i)
hst : s ∩ ⋂ i, t i = ∅
⊢ ∃ u, s ∩ ⋂ i ∈ u, t i = ∅
state_after: no goals
Theorem: CategoryTheory.CostructuredArrow.hom_eq_iff
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

tactic: rw [h]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y✝ Y' Y'' : C
S S' : C ⥤ D
X Y : CostructuredArrow S T
f g : X ⟶ Y
h : f = g
⊢ f.left = g.left
state_after: no goals
Theorem: Traversable.foldrm.ofFreeMonoid_comp_of
File: Mathlib/Control/Fold.lean

tactic: ext
state_before: α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : LawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : β → α → m α
⊢ ⇑(foldrM.ofFreeMonoid f) ∘ FreeMonoid.of = foldrM.mk ∘ f
state_after: case h
α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : LawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : β → α → m α
x✝ : β
⊢ (⇑(foldrM.ofFreeMonoid f) ∘ FreeMonoid.of) x✝ = (foldrM.mk ∘ f) x✝
Theorem: SimpleGraph.disjoint_edgeSet
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rw [Set.disjoint_iff, disjoint_iff_inf_le, ← edgeSet_inf, ← edgeSet_bot, ← Set.le_iff_subset,
  OrderEmbedding.le_iff_le]
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
⊢ Disjoint G₁.edgeSet G₂.edgeSet ↔ Disjoint G₁ G₂
state_after: no goals
Theorem: Set.preimage_mul_left_singleton
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [← image_mul_left', image_singleton]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Group α
s t : Set α
a b : α
⊢ (fun x => a * x) ⁻¹' {b} = {a⁻¹ * b}
state_after: no goals
Theorem: Polynomial.sum_C_mul_X_pow_eq
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: simp_rw [C_mul_X_pow_eq_monomial, sum_monomial_eq]
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
⊢ (p.sum fun n a => C a * X ^ n) = p
state_after: no goals
Theorem: div_eq_self
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_mul_inv, mul_right_eq_self, inv_eq_one]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
⊢ a / b = a ↔ b = 1
state_after: no goals
Theorem: induced_topology_pure
File: Mathlib/Topology/StoneCech.lean

tactic: apply eq_bot_of_singletons_open
state_before: α : Type u
⊢ induced pure Ultrafilter.topologicalSpace = ⊥
state_after: case h
α : Type u
⊢ ∀ (x : α), IsOpen {x}

tactic: intro x
state_before: case h
α : Type u
⊢ ∀ (x : α), IsOpen {x}
state_after: case h
α : Type u
x : α
⊢ IsOpen {x}

tactic: use { u : Ultrafilter α | {x} ∈ u }, ultrafilter_isOpen_basic _
state_before: case h
α : Type u
x : α
⊢ IsOpen {x}
state_after: case right
α : Type u
x : α
⊢ pure ⁻¹' {u | {x} ∈ u} = {x}

tactic: simp
state_before: case right
α : Type u
x : α
⊢ pure ⁻¹' {u | {x} ∈ u} = {x}
state_after: no goals
Theorem: Ordnode.Sized.rotateR_size
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [← size_dual, dual_rotateR, hl.dual.rotateL_size, size_dual, size_dual, add_comm (size l)]
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
⊢ (l.rotateR x r).size = l.size + r.size + 1
state_after: no goals
Theorem: NoTopOrder.to_noMaxOrder
File: Mathlib/Order/Max.lean

tactic: simpa [not_le] using exists_not_le a
state_before: α✝ : Type u_1
β : Type u_2
α : Type u_3
inst✝¹ : LinearOrder α
inst✝ : NoTopOrder α
a : α
⊢ ∃ b, a < b
state_after: no goals
Theorem: MeasureTheory.measure_union_null
File: Mathlib/MeasureTheory/OuterMeasure/Basic.lean

tactic: simp [*]
state_before: α : Type u_1
ι : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
hs : μ s = 0
ht : μ t = 0
⊢ μ (s ∪ t) = 0
state_after: no goals
Theorem: partialSups_eq_ciSup_Iic
File: Mathlib/Order/PartialSups.lean

tactic: rw [ciSup_set_le_iff Set.nonempty_Iic ((Set.finite_le_nat _).image _).bddAbove,
  partialSups_le_iff]
state_before: α : Type u_1
inst✝ : ConditionallyCompleteLattice α
f : ℕ → α
n : ℕ
x✝ : α
⊢ (partialSups f) n ≤ x✝ ↔ ⨆ i, f ↑i ≤ x✝
state_after: α : Type u_1
inst✝ : ConditionallyCompleteLattice α
f : ℕ → α
n : ℕ
x✝ : α
⊢ (∀ k ≤ n, f k ≤ x✝) ↔ ∀ i ∈ Set.Iic n, f i ≤ x✝

tactic: rfl
state_before: α : Type u_1
inst✝ : ConditionallyCompleteLattice α
f : ℕ → α
n : ℕ
x✝ : α
⊢ (∀ k ≤ n, f k ≤ x✝) ↔ ∀ i ∈ Set.Iic n, f i ≤ x✝
state_after: no goals
Theorem: Primrec₂.of_eq
File: Mathlib/Computability/Primrec.lean

tactic: funext a b
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f g : α → β → σ
hg : Primrec₂ f
H : ∀ (a : α) (b : β), f a b = g a b
⊢ f = g
state_after: case h.h
α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f g : α → β → σ
hg : Primrec₂ f
H : ∀ (a : α) (b : β), f a b = g a b
a : α
b : β
⊢ f a b = g a b

tactic: apply H
state_before: case h.h
α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f g : α → β → σ
hg : Primrec₂ f
H : ∀ (a : α) (b : β), f a b = g a b
a : α
b : β
⊢ f a b = g a b
state_after: no goals
Theorem: Nat.coprime_add_mul_right_right
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [Coprime, Coprime, gcd_add_mul_right_right]
state_before: m n k : ℕ
⊢ m.Coprime (n + k * m) ↔ m.Coprime n
state_after: no goals
Theorem: Polynomial.C_mul_comp
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: induction p using Polynomial.induction_on' with
| h_add p q hp hq =>
  simp [hp, hq, mul_add]
| h_monomial n b =>
  simp [mul_assoc]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ (C a * p).comp r = C a * p.comp r
state_after: no goals

tactic: simp [hp, hq, mul_add]
state_before: case h_add
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
hp : (C a * p).comp r = C a * p.comp r
hq : (C a * q).comp r = C a * q.comp r
⊢ (C a * (p + q)).comp r = C a * (p + q).comp r
state_after: no goals

tactic: simp [mul_assoc]
state_before: case h_monomial
R : Type u
S : Type v
T : Type w
ι : Type y
a b✝ : R
m n✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
b : R
⊢ (C a * (monomial n) b).comp r = C a * ((monomial n) b).comp r
state_after: no goals
Theorem: Cardinal.natCast_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_mk_fin, ← lift_mk_fin, lift_le, le_def, Function.Embedding.nonempty_iff_card_le,
  Fintype.card_fin, Fintype.card_fin]
state_before: α β : Type u
m n : ℕ
⊢ ↑m ≤ ↑n ↔ m ≤ n
state_after: no goals
Theorem: CompositionAsSet.toComposition_length
File: Mathlib/Combinatorics/Enumerative/Composition.lean

tactic: simp [CompositionAsSet.toComposition, Composition.length, Composition.blocks]
state_before: n : ℕ
c : CompositionAsSet n
⊢ c.toComposition.length = c.length
state_after: no goals
Theorem: SameRay.of_subsingleton
File: Mathlib/LinearAlgebra/Ray.lean

tactic: rw [Subsingleton.elim x 0]
state_before: R : Type u_1
inst✝⁶ : StrictOrderedCommSemiring R
M : Type u_2
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
N : Type u_3
inst✝³ : AddCommMonoid N
inst✝² : Module R N
ι : Type u_4
inst✝¹ : DecidableEq ι
x✝ y✝ z : M
inst✝ : Subsingleton M
x y : M
⊢ SameRay R x y
state_after: R : Type u_1
inst✝⁶ : StrictOrderedCommSemiring R
M : Type u_2
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
N : Type u_3
inst✝³ : AddCommMonoid N
inst✝² : Module R N
ι : Type u_4
inst✝¹ : DecidableEq ι
x✝ y✝ z : M
inst✝ : Subsingleton M
x y : M
⊢ SameRay R 0 y

tactic: exact zero_left _
state_before: R : Type u_1
inst✝⁶ : StrictOrderedCommSemiring R
M : Type u_2
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
N : Type u_3
inst✝³ : AddCommMonoid N
inst✝² : Module R N
ι : Type u_4
inst✝¹ : DecidableEq ι
x✝ y✝ z : M
inst✝ : Subsingleton M
x y : M
⊢ SameRay R 0 y
state_after: no goals
Theorem: Subsemiring.toNonUnitalSubsemiring_toSubsemiring
File: Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean

tactic: cases S
state_before: R : Type u_1
inst✝ : NonAssocSemiring R
S : Subsemiring R
⊢ S.toNonUnitalSubsemiring.toSubsemiring ⋯ = S
state_after: case mk
R : Type u_1
inst✝ : NonAssocSemiring R
toSubmonoid✝ : Submonoid R
add_mem'✝ : ∀ {a b : R}, a ∈ toSubmonoid✝.carrier → b ∈ toSubmonoid✝.carrier → a + b ∈ toSubmonoid✝.carrier
zero_mem'✝ : 0 ∈ toSubmonoid✝.carrier
⊢ { toSubmonoid := toSubmonoid✝, add_mem' := add_mem'✝, zero_mem' := zero_mem'✝ }.toNonUnitalSubsemiring.toSubsemiring
      ⋯ =
    { toSubmonoid := toSubmonoid✝, add_mem' := add_mem'✝, zero_mem' := zero_mem'✝ }

tactic: rfl
state_before: case mk
R : Type u_1
inst✝ : NonAssocSemiring R
toSubmonoid✝ : Submonoid R
add_mem'✝ : ∀ {a b : R}, a ∈ toSubmonoid✝.carrier → b ∈ toSubmonoid✝.carrier → a + b ∈ toSubmonoid✝.carrier
zero_mem'✝ : 0 ∈ toSubmonoid✝.carrier
⊢ { toSubmonoid := toSubmonoid✝, add_mem' := add_mem'✝, zero_mem' := zero_mem'✝ }.toNonUnitalSubsemiring.toSubsemiring
      ⋯ =
    { toSubmonoid := toSubmonoid✝, add_mem' := add_mem'✝, zero_mem' := zero_mem'✝ }
state_after: no goals
Theorem: Equiv.pointReflection_midpoint_right
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: rw [midpoint_comm, Equiv.pointReflection_midpoint_left]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y✝ z x y : P
⊢ (pointReflection (midpoint R x y)) y = x
state_after: no goals