tasksource/leandojo huggingface dataset:
Theorem: ENNReal.zpow_add
File: Mathlib/Data/Real/ENNReal.lean

tactic: lift x to ℝ≥0 using h'x
state_before: α : Type ?u.764582
β : Type ?u.764585
a b c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : x ≠ 0
h'x : x ≠ ⊤
m n : ℤ
⊢ x ^ (m + n) = x ^ m * x ^ n

tactic: replace hx : x ≠ 0
state_before: case intro
α : Type ?u.764582
β : Type ?u.764585
a b c d : ℝ≥0∞
r p q : ℝ≥0
m n : ℤ
x : ℝ≥0
hx : ↑x ≠ 0
⊢ ↑x ^ (m + n) = ↑x ^ m * ↑x ^ n

tactic: simp only [← coe_zpow hx, zpow_add₀ hx, coe_mul]
state_before: case intro
α : Type ?u.764582
β : Type ?u.764585
a b c d : ℝ≥0∞
r p q : ℝ≥0
m n : ℤ
x : ℝ≥0
hx : x ≠ 0
⊢ ↑x ^ (m + n) = ↑x ^ m * ↑x ^ n

tactic: simpa only [Ne.def, coe_eq_zero] using hx
state_before: case hx
α : Type ?u.764582
β : Type ?u.764585
a b c d : ℝ≥0∞
r p q : ℝ≥0
m n : ℤ
x : ℝ≥0
hx : ↑x ≠ 0
⊢ x ≠ 0
Theorem: le_sup_iff
File: Mathlib/Order/Lattice.lean

tactic: exact ⟨fun h =>
  (le_total c b).imp
    (fun bc => by rwa [sup_eq_left.2 bc] at h)
    (fun bc => by rwa [sup_eq_right.2 bc] at h),
  fun h => h.elim le_sup_of_le_left le_sup_of_le_right⟩
state_before: α : Type u
β : Type v
inst✝ : LinearOrder α
a b c d : α
⊢ a ≤ b ⊔ c ↔ a ≤ b ∨ a ≤ c

tactic: rwa [sup_eq_left.2 bc] at h
state_before: α : Type u
β : Type v
inst✝ : LinearOrder α
a b c d : α
h : a ≤ b ⊔ c
bc : c ≤ b
⊢ a ≤ b

tactic: rwa [sup_eq_right.2 bc] at h
state_before: α : Type u
β : Type v
inst✝ : LinearOrder α
a b c d : α
h : a ≤ b ⊔ c
bc : b ≤ c
⊢ a ≤ c
Theorem: Multiset.count_singleton
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp only [count_cons, ← cons_zero, count_zero, zero_add]
state_before: α : Type u_1
β : Type ?u.353095
γ : Type ?u.353098
inst✝ : DecidableEq α
a b : α
⊢ count a {b} = if a = b then 1 else 0
Theorem: Set.image_sub_const_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [sub_eq_add_neg, add_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ (fun x => x - a) '' [[b, c]] = [[b - a, c - a]]
Theorem: CategoryTheory.Limits.zeroProdIso_inv_snd
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

tactic: dsimp [zeroProdIso, binaryFanZeroLeft]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ (zeroProdIso X).inv ≫ prod.snd = 𝟙 X

tactic: simp
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ (limit.isoLimitCone { cone := BinaryFan.mk 0 (𝟙 X), isLimit := binaryFanZeroLeftIsLimit X }).inv ≫ prod.snd = 𝟙 X
Theorem: Filter.Tendsto.uniformity_trans
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: refine' le_trans (le_lift'.2 fun s hs => mem_map.2 _) comp_le_uniformity
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.47087
inst✝ : UniformSpace α
l : Filter β
f₁ f₂ f₃ : β → α
h₁₂ : Tendsto (fun x => (f₁ x, f₂ x)) l (𝓤 α)
h₂₃ : Tendsto (fun x => (f₂ x, f₃ x)) l (𝓤 α)
⊢ Tendsto (fun x => (f₁ x, f₃ x)) l (𝓤 α)

tactic: filter_upwards [mem_map.1 (h₁₂ hs), mem_map.1 (h₂₃ hs)] with x hx₁₂ hx₂₃ using ⟨_, hx₁₂, hx₂₃⟩
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.47087
inst✝ : UniformSpace α
l : Filter β
f₁ f₂ f₃ : β → α
h₁₂ : Tendsto (fun x => (f₁ x, f₂ x)) l (𝓤 α)
h₂₃ : Tendsto (fun x => (f₂ x, f₃ x)) l (𝓤 α)
s : Set (α × α)
hs : s ∈ 𝓤 α
⊢ (fun x => (f₁ x, f₃ x)) ⁻¹' (s ○ s) ∈ l
Theorem: val_div_eq_divp
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [divp, division_def, Units.val_mul]
state_before: α : Type u
inst✝ : Monoid α
a b c : α
u₁ u₂ : αˣ
⊢ ↑(u₁ / u₂) = ↑u₁ /ₚ u₂
Theorem: le_of_forall_one_lt_le_mul
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

tactic: obtain ⟨ε, rfl⟩ := exists_mul_of_le hxb.le
state_before: α : Type u
inst✝⁵ : LinearOrder α
inst✝⁴ : DenselyOrdered α
inst✝³ : Monoid α
inst✝² : ExistsMulOfLE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
h : ∀ (ε : α), 1 < ε → a ≤ b * ε
x : α
hxb : b < x
⊢ a ≤ x

tactic: exact h _ ((lt_mul_iff_one_lt_right' b).1 hxb)
state_before: case intro
α : Type u
inst✝⁵ : LinearOrder α
inst✝⁴ : DenselyOrdered α
inst✝³ : Monoid α
inst✝² : ExistsMulOfLE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
h : ∀ (ε : α), 1 < ε → a ≤ b * ε
ε : α
hxb : b < b * ε
⊢ a ≤ b * ε
Theorem: FirstOrder.Language.elementarilyEquivalent_iff
File: Mathlib/ModelTheory/Semantics.lean

tactic: simp only [ElementarilyEquivalent, Set.ext_iff, completeTheory, Set.mem_setOf_eq]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type ?u.269466
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
⊢ M ≅[L] N ↔ ∀ (φ : Sentence L), M ⊨ φ ↔ N ⊨ φ
Theorem: GeneralizedContinuedFraction.IntFractPair.exists_succ_get?_stream_of_gcf_of_get?_eq_some
File: Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean

tactic: obtain ⟨ifp, stream_succ_nth_eq, gp_n_eq⟩ :
  ∃ ifp, IntFractPair.stream v (n + 1) = some ifp ∧ Pair.mk 1 (ifp.b : K) = gp_n := by
  unfold of IntFractPair.seq1 at s_nth_eq
  simpa [Stream'.Seq.get?_tail, Stream'.Seq.map_get?] using s_nth_eq
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
gp_n : Pair K
s_nth_eq : Stream'.Seq.get? (of v).s n = some gp_n
⊢ ∃ ifp, IntFractPair.stream v (n + 1) = some ifp ∧ ↑ifp.b = gp_n.b

tactic: cases gp_n_eq
state_before: case intro.intro
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
gp_n : Pair K
s_nth_eq : Stream'.Seq.get? (of v).s n = some gp_n
ifp : IntFractPair K
stream_succ_nth_eq : IntFractPair.stream v (n + 1) = some ifp
gp_n_eq : { a := 1, b := ↑ifp.b } = gp_n
⊢ ∃ ifp, IntFractPair.stream v (n + 1) = some ifp ∧ ↑ifp.b = gp_n.b

tactic: simp_all only [Option.some.injEq, exists_eq_left']
state_before: case intro.intro.refl
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
ifp : IntFractPair K
stream_succ_nth_eq : IntFractPair.stream v (n + 1) = some ifp
s_nth_eq : Stream'.Seq.get? (of v).s n = some { a := 1, b := ↑ifp.b }
⊢ ∃ ifp_1, IntFractPair.stream v (n + 1) = some ifp_1 ∧ ↑ifp_1.b = { a := 1, b := ↑ifp.b }.b

tactic: unfold of IntFractPair.seq1 at s_nth_eq
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
gp_n : Pair K
s_nth_eq : Stream'.Seq.get? (of v).s n = some gp_n
⊢ ∃ ifp, IntFractPair.stream v (n + 1) = some ifp ∧ { a := 1, b := ↑ifp.b } = gp_n

tactic: simpa [Stream'.Seq.get?_tail, Stream'.Seq.map_get?] using s_nth_eq
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
gp_n : Pair K
s_nth_eq :
  Stream'.Seq.get?
      (match
          (IntFractPair.of v,
            Stream'.Seq.tail
              { val := IntFractPair.stream v, property := (_ : Stream'.IsSeq (IntFractPair.stream v)) }) with
        | (h, s) => { h := ↑h.b, s := Stream'.Seq.map (fun p => { a := 1, b := ↑p.b }) s }).s
      n =
    some gp_n
⊢ ∃ ifp, IntFractPair.stream v (n + 1) = some ifp ∧ { a := 1, b := ↑ifp.b } = gp_n
Theorem: Fin.succAbove_cycleRange
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: cases n
state_before: n : ℕ
i j : Fin n
⊢ ↑(succAbove (succ i)) (↑(cycleRange i) j) = ↑(swap 0 (succ i)) (succ j)

tactic: rcases lt_trichotomy j i with (hlt | heq | hgt)
state_before: case succ
n✝ : ℕ
i j : Fin (Nat.succ n✝)
⊢ ↑(succAbove (succ i)) (↑(cycleRange i) j) = ↑(swap 0 (succ i)) (succ j)

tactic: rcases j with ⟨_, ⟨⟩⟩
state_before: case zero
i j : Fin Nat.zero
⊢ ↑(succAbove (succ i)) (↑(cycleRange i) j) = ↑(swap 0 (succ i)) (succ j)

tactic: have : castSucc (j + 1) = j.succ := by
  ext
  rw [coe_castSucc, val_succ, Fin.val_add_one_of_lt (lt_of_lt_of_le hlt i.le_last)]
state_before: case succ.inl
n✝ : ℕ
i j : Fin (Nat.succ n✝)
hlt : j < i
⊢ ↑(succAbove (succ i)) (↑(cycleRange i) j) = ↑(swap 0 (succ i)) (succ j)

tactic: rw [Fin.cycleRange_of_lt hlt, Fin.succAbove_below, this, swap_apply_of_ne_of_ne]
state_before: case succ.inl
n✝ : ℕ
i j : Fin (Nat.succ n✝)
hlt : j < i
this : ↑castSucc (j + 1) = succ j
⊢ ↑(succAbove (succ i)) (↑(cycleRange i) j) = ↑(swap 0 (succ i)) (succ j)

tactic: ext
state_before: n✝ : ℕ
i j : Fin (Nat.succ n✝)
hlt : j < i
⊢ ↑castSucc (j + 1) = succ j

tactic: rw [coe_castSucc, val_succ, Fin.val_add_one_of_lt (lt_of_lt_of_le hlt i.le_last)]
state_before: case h
n✝ : ℕ
i j : Fin (Nat.succ n✝)
hlt : j < i
⊢ ↑(↑castSucc (j + 1)) = ↑(succ j)

tactic: apply Fin.succ_ne_zero
state_before: case succ.inl.a
n✝ : ℕ
i j : Fin (Nat.succ n✝)
hlt : j < i
this : ↑castSucc (j + 1) = succ j
⊢ succ j ≠ 0

tactic: exact (Fin.succ_injective _).ne hlt.ne
state_before: case succ.inl.a
n✝ : ℕ
i j : Fin (Nat.succ n✝)
hlt : j < i
this : ↑castSucc (j + 1) = succ j
⊢ succ j ≠ succ i

tactic: rw [Fin.lt_iff_val_lt_val]
state_before: case succ.inl.h
n✝ : ℕ
i j : Fin (Nat.succ n✝)
hlt : j < i
this : ↑castSucc (j + 1) = succ j
⊢ ↑castSucc (j + 1) < succ i

tactic: simpa [this] using hlt
state_before: case succ.inl.h
n✝ : ℕ
i j : Fin (Nat.succ n✝)
hlt : j < i
this : ↑castSucc (j + 1) = succ j
⊢ ↑(↑castSucc (j + 1)) < ↑(succ i)

tactic: rw [heq, Fin.cycleRange_self, Fin.succAbove_below, swap_apply_right, Fin.castSucc_zero]
state_before: case succ.inr.inl
n✝ : ℕ
i j : Fin (Nat.succ n✝)
heq : j = i
⊢ ↑(succAbove (succ i)) (↑(cycleRange i) j) = ↑(swap 0 (succ i)) (succ j)

tactic: rw [Fin.castSucc_zero]
state_before: case succ.inr.inl.h
n✝ : ℕ
i j : Fin (Nat.succ n✝)
heq : j = i
⊢ ↑castSucc 0 < succ i

tactic: apply Fin.succ_pos
state_before: case succ.inr.inl.h
n✝ : ℕ
i j : Fin (Nat.succ n✝)
heq : j = i
⊢ 0 < succ i

tactic: rw [Fin.cycleRange_of_gt hgt, Fin.succAbove_above, swap_apply_of_ne_of_ne]
state_before: case succ.inr.inr
n✝ : ℕ
i j : Fin (Nat.succ n✝)
hgt : i < j
⊢ ↑(succAbove (succ i)) (↑(cycleRange i) j) = ↑(swap 0 (succ i)) (succ j)

tactic: apply Fin.succ_ne_zero
state_before: case succ.inr.inr.a
n✝ : ℕ
i j : Fin (Nat.succ n✝)
hgt : i < j
⊢ succ j ≠ 0

tactic: apply (Fin.succ_injective _).ne hgt.ne.symm
state_before: case succ.inr.inr.a
n✝ : ℕ
i j : Fin (Nat.succ n✝)
hgt : i < j
⊢ succ j ≠ succ i

tactic: simpa [Fin.le_iff_val_le_val] using hgt
state_before: case succ.inr.inr.h
n✝ : ℕ
i j : Fin (Nat.succ n✝)
hgt : i < j
⊢ succ i ≤ ↑castSucc j
Theorem: ConcaveOn.slope_anti_adjacent
File: Mathlib/Analysis/Convex/Slope.lean

tactic: have := neg_le_neg (ConvexOn.slope_mono_adjacent hf.neg hx hz hxy hyz)
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
⊢ (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)

tactic: simp only [Pi.neg_apply, ← neg_div, neg_sub', neg_neg] at this
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
this : -(((-f) z - (-f) y) / (z - y)) ≤ -(((-f) y - (-f) x) / (y - x))
⊢ (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)

tactic: exact this
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
this : (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
⊢ (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
Theorem: Polynomial.toFinsupp_apply
File: Mathlib/Data/Polynomial/Basic.lean

tactic: cases f
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q f : R[X]
i : ℕ
⊢ ↑f.toFinsupp i = coeff f i

tactic: rfl
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
i : ℕ
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ ↑{ toFinsupp := toFinsupp✝ }.toFinsupp i = coeff { toFinsupp := toFinsupp✝ } i
Theorem: MeasureTheory.OuterMeasure.map_le_restrict_range
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simpa using h (s ∩ range f)
state_before: α : Type u_2
β✝ : Type ?u.120092
R : Type ?u.120095
R' : Type ?u.120098
ms : Set (OuterMeasure α)
m : OuterMeasure α
β : Type u_1
ma : OuterMeasure α
mb : OuterMeasure β
f : α → β
h : ↑(map f) ma ≤ mb
s : Set β
⊢ ↑(↑(map f) ma) s ≤ ↑(↑(restrict (range f)) mb) s
Theorem: IsPrimitiveRoot.inv_iff
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: refine' ⟨_, fun h => inv h⟩
state_before: M : Type ?u.2707095
N : Type ?u.2707098
G : Type u_1
R : Type ?u.2707104
S : Type ?u.2707107
F : Type ?u.2707110
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l : ℕ
ζ : G
⊢ IsPrimitiveRoot ζ⁻¹ k ↔ IsPrimitiveRoot ζ k

tactic: intro h
state_before: M : Type ?u.2707095
N : Type ?u.2707098
G : Type u_1
R : Type ?u.2707104
S : Type ?u.2707107
F : Type ?u.2707110
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l : ℕ
ζ : G
⊢ IsPrimitiveRoot ζ⁻¹ k → IsPrimitiveRoot ζ k

tactic: rw [← inv_inv ζ]
state_before: M : Type ?u.2707095
N : Type ?u.2707098
G : Type u_1
R : Type ?u.2707104
S : Type ?u.2707107
F : Type ?u.2707110
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l : ℕ
ζ : G
h : IsPrimitiveRoot ζ⁻¹ k
⊢ IsPrimitiveRoot ζ k

tactic: exact inv h
state_before: M : Type ?u.2707095
N : Type ?u.2707098
G : Type u_1
R : Type ?u.2707104
S : Type ?u.2707107
F : Type ?u.2707110
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l : ℕ
ζ : G
h : IsPrimitiveRoot ζ⁻¹ k
⊢ IsPrimitiveRoot ζ⁻¹⁻¹ k
Theorem: Set.exists_prod_set
File: Mathlib/Data/Set/Prod.lean

tactic: simp [and_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.3341
δ : Type ?u.3344
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
p : α × β → Prop
⊢ (∃ x, x ∈ s ×ˢ t ∧ p x) ↔ ∃ x, x ∈ s ∧ ∃ y, y ∈ t ∧ p (x, y)
Theorem: CategoryTheory.Sheaf.le_finestTopology
File: Mathlib/CategoryTheory/Sites/Canonical.lean

tactic: rintro X S hS _ ⟨⟨_, _, ⟨P, hP, rfl⟩, rfl⟩, rfl⟩
state_before: C : Type u
inst✝ : Category C
P : Cᵒᵖ ⥤ Type v
X Y : C
S : Sieve X
R : Presieve X
J✝ J₂ : GrothendieckTopology C
Ps : Set (Cᵒᵖ ⥤ Type v)
J : GrothendieckTopology C
hJ : ∀ (P : Cᵒᵖ ⥤ Type v), P ∈ Ps → Presieve.IsSheaf J P
⊢ J ≤ finestTopology Ps

tactic: intro Y f
state_before: case intro.mk.intro.intro.intro.intro
C : Type u
inst✝ : Category C
P✝ : Cᵒᵖ ⥤ Type v
X✝ Y : C
S✝ : Sieve X✝
R : Presieve X✝
J✝ J₂ : GrothendieckTopology C
Ps : Set (Cᵒᵖ ⥤ Type v)
J : GrothendieckTopology C
hJ : ∀ (P : Cᵒᵖ ⥤ Type v), P ∈ Ps → Presieve.IsSheaf J P
X : C
S : Sieve X
hS : S ∈ GrothendieckTopology.sieves J X
P : Cᵒᵖ ⥤ Type v
hP : P ∈ Ps
⊢ S ∈
    (fun f => ↑f X)
      { val := (finestTopologySingle P).sieves,
        property := (_ : ∃ a, a ∈ finestTopologySingle '' Ps ∧ a.sieves = (finestTopologySingle P).sieves) }

tactic: exact hJ P hP (S.pullback f) (J.pullback_stable f hS)
state_before: case intro.mk.intro.intro.intro.intro
C : Type u
inst✝ : Category C
P✝ : Cᵒᵖ ⥤ Type v
X✝ Y✝ : C
S✝ : Sieve X✝
R : Presieve X✝
J✝ J₂ : GrothendieckTopology C
Ps : Set (Cᵒᵖ ⥤ Type v)
J : GrothendieckTopology C
hJ : ∀ (P : Cᵒᵖ ⥤ Type v), P ∈ Ps → Presieve.IsSheaf J P
X : C
S : Sieve X
hS : S ∈ GrothendieckTopology.sieves J X
P : Cᵒᵖ ⥤ Type v
hP : P ∈ Ps
Y : C
f : Y ⟶ X
⊢ Presieve.IsSheafFor P (Sieve.pullback f S).arrows
Theorem: Function.Antiperiodic.sub
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [sub_eq_add_neg] using h1.add h2.neg
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.210172
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h1 : Antiperiodic f c₁
h2 : Antiperiodic f c₂
⊢ Periodic f (c₁ - c₂)
Theorem: Function.Periodic.comp_addHom
File: Mathlib/Algebra/Periodic.lean

tactic: simp only [hg c, h (g x), map_add, comp_apply]
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
f g✝ : α → β
c c₁ c₂ x✝ : α
inst✝¹ : Add α
inst✝ : Add γ
h : Periodic f c
g : AddHom γ α
g_inv : α → γ
hg : RightInverse g_inv ↑g
x : γ
⊢ (f ∘ ↑g) (x + g_inv c) = (f ∘ ↑g) x
Theorem: Real.exp_sub
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sub_eq_add_neg, exp_add, exp_neg, div_eq_mul_inv]
state_before: x y : ℝ
⊢ exp (x - y) = exp x / exp y
Theorem: Module.End.hasGeneralizedEigenvalue_of_hasEigenvalue
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: apply hasGeneralizedEigenvalue_of_hasGeneralizedEigenvalue_of_le hk
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hk : 0 < k
hμ : HasEigenvalue f μ
⊢ HasGeneralizedEigenvalue f μ k

tactic: rw [HasGeneralizedEigenvalue, generalizedEigenspace, OrderHom.coe_fun_mk, pow_one]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hk : 0 < k
hμ : HasEigenvalue f μ
⊢ HasGeneralizedEigenvalue f μ (Nat.succ 0)

tactic: exact hμ
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hk : 0 < k
hμ : HasEigenvalue f μ
⊢ LinearMap.ker (f - ↑(algebraMap R (End R M)) μ) ≠ ⊥
Theorem: sdiff_unique
File: Mathlib/Order/BooleanAlgebra.lean

tactic: conv_rhs at s => rw [← sup_inf_sdiff x y, sup_comm]
state_before: α : Type u
β : Type ?u.2138
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
s : x ⊓ y ⊔ z = x
i : x ⊓ y ⊓ z = ⊥
⊢ x \ y = z

tactic: rw [sup_comm] at s
state_before: α : Type u
β : Type ?u.2138
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
s : x ⊓ y ⊔ z = x \ y ⊔ x ⊓ y
i : x ⊓ y ⊓ z = ⊥
⊢ x \ y = z

tactic: conv_rhs at i => rw [← inf_inf_sdiff x y, inf_comm]
state_before: α : Type u
β : Type ?u.2138
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
s : z ⊔ x ⊓ y = x \ y ⊔ x ⊓ y
i : x ⊓ y ⊓ z = ⊥
⊢ x \ y = z

tactic: rw [inf_comm] at i
state_before: α : Type u
β : Type ?u.2138
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
s : z ⊔ x ⊓ y = x \ y ⊔ x ⊓ y
i : x ⊓ y ⊓ z = x \ y ⊓ (x ⊓ y)
⊢ x \ y = z

tactic: exact (eq_of_inf_eq_sup_eq i s).symm
state_before: α : Type u
β : Type ?u.2138
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
s : z ⊔ x ⊓ y = x \ y ⊔ x ⊓ y
i : z ⊓ (x ⊓ y) = x \ y ⊓ (x ⊓ y)
⊢ x \ y = z
Theorem: AlgebraicGeometry.StructureSheaf.comap_id'
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: rwa [PrimeSpectrum.comap_id]
state_before: R : Type u
inst✝² : CommRing R
S : Type u
inst✝¹ : CommRing S
P : Type u
inst✝ : CommRing P
U : Opens ↑(PrimeSpectrum.Top R)
p : ↑(PrimeSpectrum.Top R)
hpU : p ∈ U.carrier
⊢ p ∈ ↑(PrimeSpectrum.comap (RingHom.id R)) ⁻¹' U.carrier

tactic: rw [comap_id U U rfl]
state_before: R : Type u
inst✝² : CommRing R
S : Type u
inst✝¹ : CommRing S
P : Type u
inst✝ : CommRing P
U : Opens ↑(PrimeSpectrum.Top R)
⊢ comap (RingHom.id R) U U
      (_ : ∀ (p : ↑(PrimeSpectrum.Top R)), p ∈ U.carrier → p ∈ ↑(PrimeSpectrum.comap (RingHom.id R)) ⁻¹' U.carrier) =
    RingHom.id ↑((structureSheaf R).val.obj U.op)

tactic: rfl
state_before: R : Type u
inst✝² : CommRing R
S : Type u
inst✝¹ : CommRing S
P : Type u
inst✝ : CommRing P
U : Opens ↑(PrimeSpectrum.Top R)
⊢ eqToHom (_ : (structureSheaf R).val.obj U.op = (structureSheaf R).val.obj U.op) =
    RingHom.id ↑((structureSheaf R).val.obj U.op)
Theorem: Turing.tr_eval
File: Mathlib/Computability/TuringMachine.lean

tactic: cases' mem_eval.1 ab with ab b0
state_before: σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ b₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
ab : b₁ ∈ eval f₁ a₁
⊢ ∃ b₂, tr b₁ b₂ ∧ b₂ ∈ eval f₂ a₂

tactic: rcases tr_reaches H aa ab with ⟨b₂, bb, ab⟩
state_before: case intro
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ b₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
ab✝ : b₁ ∈ eval f₁ a₁
ab : Reaches f₁ a₁ b₁
b0 : f₁ b₁ = none
⊢ ∃ b₂, tr b₁ b₂ ∧ b₂ ∈ eval f₂ a₂

tactic: refine' ⟨_, bb, mem_eval.2 ⟨ab, _⟩⟩
state_before: case intro.intro.intro
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ b₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
ab✝¹ : b₁ ∈ eval f₁ a₁
ab✝ : Reaches f₁ a₁ b₁
b0 : f₁ b₁ = none
b₂ : σ₂
bb : tr b₁ b₂
ab : Reaches f₂ a₂ b₂
⊢ ∃ b₂, tr b₁ b₂ ∧ b₂ ∈ eval f₂ a₂

tactic: have := H bb
state_before: case intro.intro.intro
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ b₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
ab✝¹ : b₁ ∈ eval f₁ a₁
ab✝ : Reaches f₁ a₁ b₁
b0 : f₁ b₁ = none
b₂ : σ₂
bb : tr b₁ b₂
ab : Reaches f₂ a₂ b₂
⊢ f₂ b₂ = none

tactic: rwa [b0] at this
state_before: case intro.intro.intro
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ b₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
ab✝¹ : b₁ ∈ eval f₁ a₁
ab✝ : Reaches f₁ a₁ b₁
b0 : f₁ b₁ = none
b₂ : σ₂
bb : tr b₁ b₂
ab : Reaches f₂ a₂ b₂
this :
  match f₁ b₁ with
  | some b₁ => ∃ b₂_1, tr b₁ b₂_1 ∧ Reaches₁ f₂ b₂ b₂_1
  | none => f₂ b₂ = none
⊢ f₂ b₂ = none
Theorem: Multiset.Ico_filter_le_left
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: rw [Ico, ← Finset.filter_val, Finset.Ico_filter_le_left hab]
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ a b : α
inst✝ : DecidablePred fun x => x ≤ a
hab : a < b
⊢ filter (fun x => x ≤ a) (Ico a b) = {a}

tactic: rfl
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ a b : α
inst✝ : DecidablePred fun x => x ≤ a
hab : a < b
⊢ {a}.val = {a}
Theorem: Subgroup.Normal.mem_comm
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: have : a⁻¹ * (a * b) * a⁻¹⁻¹ ∈ H := nH.conj_mem (a * b) h a⁻¹
state_before: G : Type u_1
G' : Type ?u.339502
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.339511
inst✝ : AddGroup A
H K : Subgroup G
nH : Normal H
a b : G
h : a * b ∈ H
⊢ b * a ∈ H

tactic: simp_all only [inv_mul_cancel_left, inv_inv]
state_before: G : Type u_1
G' : Type ?u.339502
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.339511
inst✝ : AddGroup A
H K : Subgroup G
nH : Normal H
a b : G
h : a * b ∈ H
this : a⁻¹ * (a * b) * a⁻¹⁻¹ ∈ H
⊢ b * a ∈ H
Theorem: CategoryTheory.Limits.Cone.ofFork_π
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: aesop
state_before: C : Type u
inst✝ : Category C
X Y : C
f g : X ⟶ Y
F : WalkingParallelPair ⥤ C
t : Fork (F.map left) (F.map right)
j : WalkingParallelPair
⊢ (parallelPair (F.map left) (F.map right)).obj j = F.obj j