1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Set.preimage_sub_const_Ico
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [sub_eq_add_neg]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x - a) ⁻¹' Ico b c = Ico (b + a) (c + a)
state_after: no goals
Theorem: Batteries.compareOfLessAndEq_eq_lt
File: .lake/packages/batteries/Batteries/Classes/Order.lean

tactic: simp [compareOfLessAndEq]
state_before: α : Type u_1
x y : α
inst✝² : LT α
inst✝¹ : Decidable (x < y)
inst✝ : DecidableEq α
⊢ compareOfLessAndEq x y = Ordering.lt ↔ x < y
state_after: α : Type u_1
x y : α
inst✝² : LT α
inst✝¹ : Decidable (x < y)
inst✝ : DecidableEq α
⊢ ¬x < y → (if x = y then Ordering.eq else Ordering.gt) = Ordering.lt ↔ x < y

tactic: split <;> simp
state_before: α : Type u_1
x y : α
inst✝² : LT α
inst✝¹ : Decidable (x < y)
inst✝ : DecidableEq α
⊢ ¬x < y → (if x = y then Ordering.eq else Ordering.gt) = Ordering.lt ↔ x < y
state_after: no goals
Theorem: Stream'.WSeq.liftRel_cons
File: Mathlib/Data/Seq/WSeq.lean

tactic: rw [liftRel_destruct_iff]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
s : WSeq α
t : WSeq β
⊢ LiftRel R (cons a s) (cons b t) ↔ R a b ∧ LiftRel R s t
state_after: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
s : WSeq α
t : WSeq β
⊢ Computation.LiftRel (LiftRelO R (LiftRel R)) (cons a s).destruct (cons b t).destruct ↔ R a b ∧ LiftRel R s t

tactic: simp [-liftRel_pure_left, -liftRel_pure_right]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
s : WSeq α
t : WSeq β
⊢ Computation.LiftRel (LiftRelO R (LiftRel R)) (cons a s).destruct (cons b t).destruct ↔ R a b ∧ LiftRel R s t
state_after: no goals
Theorem: Finset.filter_filter
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_filter, and_assoc, Bool.decide_and, Bool.decide_coe, Bool.and_eq_true]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
s✝ s : Finset α
a : α
⊢ a ∈ filter q (filter p s) ↔ a ∈ filter (fun a => p a ∧ q a) s
state_after: no goals
Theorem: ENNReal.toReal_div
File: Mathlib/Data/ENNReal/Real.lean

tactic: rw [div_eq_mul_inv, toReal_mul, toReal_inv, div_eq_mul_inv]
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
⊢ (a / b).toReal = a.toReal / b.toReal
state_after: no goals
Theorem: Primrec.dom_fintype
File: Mathlib/Computability/Primrec.lean

tactic: haveI := decidableEqOfEncodable α
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁵ : Primcodable α
inst✝⁴ : Primcodable β
inst✝³ : Primcodable γ
inst✝² : Primcodable δ
inst✝¹ : Primcodable σ
inst✝ : Finite α
f : α → σ
l : List α
left✝ : l.Nodup
m : ∀ (x : α), x ∈ l
⊢ Primrec fun a => some (f a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁵ : Primcodable α
inst✝⁴ : Primcodable β
inst✝³ : Primcodable γ
inst✝² : Primcodable δ
inst✝¹ : Primcodable σ
inst✝ : Finite α
f : α → σ
l : List α
left✝ : l.Nodup
m : ∀ (x : α), x ∈ l
this : DecidableEq α
⊢ Primrec fun a => some (f a)

tactic: refine ((list_get?₁ (l.map f)).comp (list_indexOf₁ l)).of_eq fun a => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁵ : Primcodable α
inst✝⁴ : Primcodable β
inst✝³ : Primcodable γ
inst✝² : Primcodable δ
inst✝¹ : Primcodable σ
inst✝ : Finite α
f : α → σ
l : List α
left✝ : l.Nodup
m : ∀ (x : α), x ∈ l
this : DecidableEq α
⊢ Primrec fun a => some (f a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁵ : Primcodable α
inst✝⁴ : Primcodable β
inst✝³ : Primcodable γ
inst✝² : Primcodable δ
inst✝¹ : Primcodable σ
inst✝ : Finite α
f : α → σ
l : List α
left✝ : l.Nodup
m : ∀ (x : α), x ∈ l
this : DecidableEq α
a : α
⊢ (List.map f l).get? (List.indexOf a l) = some (f a)

tactic: rw [List.get?_eq_getElem?, List.getElem?_map, List.getElem?_indexOf  (m a), Option.map_some']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁵ : Primcodable α
inst✝⁴ : Primcodable β
inst✝³ : Primcodable γ
inst✝² : Primcodable δ
inst✝¹ : Primcodable σ
inst✝ : Finite α
f : α → σ
l : List α
left✝ : l.Nodup
m : ∀ (x : α), x ∈ l
this : DecidableEq α
a : α
⊢ (List.map f l).get? (List.indexOf a l) = some (f a)
state_after: no goals
Theorem: FirstOrder.Language.Substructure.fg_bot
File: Mathlib/ModelTheory/FinitelyGenerated.lean

tactic: rw [Finset.coe_empty, closure_empty]
state_before: L : Language
M : Type u_1
inst✝ : L.Structure M
⊢ (closure L).toFun ↑∅ = ⊥
state_after: no goals
Theorem: Filter.cardinal_iInter_mem
File: Mathlib/Order/Filter/CardinalInter.lean

tactic: rw [← sInter_range _]
state_before: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
s : ι → Set α
hic : #ι < c
⊢ ⋂ i, s i ∈ l ↔ ∀ (i : ι), s i ∈ l
state_after: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
s : ι → Set α
hic : #ι < c
⊢ ⋂₀ range s ∈ l ↔ ∀ (i : ι), s i ∈ l

tactic: apply (cardinal_sInter_mem (lt_of_le_of_lt Cardinal.mk_range_le hic)).trans
state_before: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
s : ι → Set α
hic : #ι < c
⊢ ⋂₀ range s ∈ l ↔ ∀ (i : ι), s i ∈ l
state_after: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
s : ι → Set α
hic : #ι < c
⊢ (∀ s_1 ∈ range s, s_1 ∈ l) ↔ ∀ (i : ι), s i ∈ l

tactic: exact forall_mem_range
state_before: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
s : ι → Set α
hic : #ι < c
⊢ (∀ s_1 ∈ range s, s_1 ∈ l) ↔ ∀ (i : ι), s i ∈ l
state_after: no goals
Theorem: Computation.le_stable
File: Mathlib/Data/Seq/Computation.lean

tactic: cases' s with f al
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
m n : ℕ
h : m ≤ n
⊢ ↑s m = some a → ↑s n = some a
state_after: case mk
α : Type u
β : Type v
γ : Type w
a : α
m n : ℕ
h : m ≤ n
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
⊢ ↑⟨f, al⟩ m = some a → ↑⟨f, al⟩ n = some a

tactic: induction' h with n _ IH
state_before: case mk
α : Type u
β : Type v
γ : Type w
a : α
m n : ℕ
h : m ≤ n
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
⊢ ↑⟨f, al⟩ m = some a → ↑⟨f, al⟩ n = some a
state_after: case mk.refl
α : Type u
β : Type v
γ : Type w
a : α
m n : ℕ
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
⊢ ↑⟨f, al⟩ m = some a → ↑⟨f, al⟩ m = some a

case mk.step
α : Type u
β : Type v
γ : Type w
a : α
m n✝ : ℕ
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
n : ℕ
a✝ : m.le n
IH : ↑⟨f, al⟩ m = some a → ↑⟨f, al⟩ n = some a
⊢ ↑⟨f, al⟩ m = some a → ↑⟨f, al⟩ n.succ = some a

tactic: exacts [id, fun h2 => al (IH h2)]
state_before: case mk.refl
α : Type u
β : Type v
γ : Type w
a : α
m n : ℕ
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
⊢ ↑⟨f, al⟩ m = some a → ↑⟨f, al⟩ m = some a

case mk.step
α : Type u
β : Type v
γ : Type w
a : α
m n✝ : ℕ
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
n : ℕ
a✝ : m.le n
IH : ↑⟨f, al⟩ m = some a → ↑⟨f, al⟩ n = some a
⊢ ↑⟨f, al⟩ m = some a → ↑⟨f, al⟩ n.succ = some a
state_after: no goals
Theorem: affineSegment_eq_segment
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [segment_eq_image_lineMap, affineSegment]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y : V
⊢ affineSegment R x y = segment R x y
state_after: no goals
Theorem: ZMod.isSquare_of_jacobiSym_eq_one
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

tactic: rw [← nonsquare_iff_jacobiSym_eq_neg_one, h]
state_before: a : ℤ
p : ℕ
inst✝ : Fact (Nat.Prime p)
h : J(a | p) = 1
⊢ ¬¬IsSquare ↑a
state_after: a : ℤ
p : ℕ
inst✝ : Fact (Nat.Prime p)
h : J(a | p) = 1
⊢ ¬1 = -1

tactic: decide
state_before: a : ℤ
p : ℕ
inst✝ : Fact (Nat.Prime p)
h : J(a | p) = 1
⊢ ¬1 = -1
state_after: no goals
Theorem: ContinuousAt.comp_of_eq
File: Mathlib/Topology/Basic.lean

tactic: subst hy
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f : X → Y
s : Set X
x : X
y : Y
g : Y → Z
hg : ContinuousAt g y
hf : ContinuousAt f x
hy : f x = y
⊢ ContinuousAt (g ∘ f) x
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f : X → Y
s : Set X
x : X
g : Y → Z
hf : ContinuousAt f x
hg : ContinuousAt g (f x)
⊢ ContinuousAt (g ∘ f) x

tactic: exact hg.comp hf
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f : X → Y
s : Set X
x : X
g : Y → Z
hf : ContinuousAt f x
hg : ContinuousAt g (f x)
⊢ ContinuousAt (g ∘ f) x
state_after: no goals
Theorem: Ordinal.nadd_assoc
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [nadd_def a (b ♯ c), nadd_def, blsub_nadd_of_mono, blsub_nadd_of_mono, max_assoc]
state_before: a✝ b✝ c✝ : Ordinal.{u}
a b c : Ordinal.{u_1}
⊢ a ♯ b ♯ c = a ♯ (b ♯ c)
state_after: a✝ b✝ c✝ : Ordinal.{u}
a b c : Ordinal.{u_1}
⊢ max (a.blsub fun a' ha' => a' ♯ b ♯ c) (max (b.blsub fun b' hb' => a ♯ b' ♯ c) (c.blsub fun b' x => a ♯ b ♯ b')) =
    max (a.blsub fun a' x => a' ♯ (b ♯ c))
      (max (b.blsub fun a' ha' => a ♯ (a' ♯ c)) (c.blsub fun b' hb' => a ♯ (b ♯ b')))

case hf
a✝ b✝ c✝ : Ordinal.{u}
a b c : Ordinal.{u_1}
⊢ ∀ {i j : Ordinal.{u_1}}, i < b ♯ c → j < b ♯ c → i ≤ j → a ♯ i ≤ a ♯ j

case hf
a✝ b✝ c✝ : Ordinal.{u}
a b c : Ordinal.{u_1}
⊢ ∀ {i j : Ordinal.{u_1}}, i < a ♯ b → j < a ♯ b → i ≤ j → i ♯ c ≤ j ♯ c

tactic: congr <;> ext <;> apply nadd_assoc
state_before: a✝ b✝ c✝ : Ordinal.{u}
a b c : Ordinal.{u_1}
⊢ max (a.blsub fun a' ha' => a' ♯ b ♯ c) (max (b.blsub fun b' hb' => a ♯ b' ♯ c) (c.blsub fun b' x => a ♯ b ♯ b')) =
    max (a.blsub fun a' x => a' ♯ (b ♯ c))
      (max (b.blsub fun a' ha' => a ♯ (a' ♯ c)) (c.blsub fun b' hb' => a ♯ (b ♯ b')))
state_after: no goals

tactic: exact fun _ _ h => nadd_le_nadd_left h a
state_before: case hf
a✝ b✝ c✝ : Ordinal.{u}
a b c : Ordinal.{u_1}
⊢ ∀ {i j : Ordinal.{u_1}}, i < b ♯ c → j < b ♯ c → i ≤ j → a ♯ i ≤ a ♯ j
state_after: no goals

tactic: exact fun _ _ h => nadd_le_nadd_right h c
state_before: case hf
a✝ b✝ c✝ : Ordinal.{u}
a b c : Ordinal.{u_1}
⊢ ∀ {i j : Ordinal.{u_1}}, i < a ♯ b → j < a ♯ b → i ≤ j → i ♯ c ≤ j ♯ c
state_after: no goals
Theorem: Polynomial.degree_mul_leadingCoeff_self_inv
File: Mathlib/Algebra/Polynomial/Degree/Lemmas.lean

tactic: by_cases hp : p = 0
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
K : Type u_1
inst✝ : DivisionRing K
p : K[X]
⊢ (p * C p.leadingCoeff⁻¹).degree = p.degree
state_after: case pos
R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
K : Type u_1
inst✝ : DivisionRing K
p : K[X]
hp : p = 0
⊢ (p * C p.leadingCoeff⁻¹).degree = p.degree

case neg
R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
K : Type u_1
inst✝ : DivisionRing K
p : K[X]
hp : ¬p = 0
⊢ (p * C p.leadingCoeff⁻¹).degree = p.degree

tactic: exact degree_mul_leadingCoeff_inv _ hp
state_before: case neg
R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
K : Type u_1
inst✝ : DivisionRing K
p : K[X]
hp : ¬p = 0
⊢ (p * C p.leadingCoeff⁻¹).degree = p.degree
state_after: no goals

tactic: simp [hp]
state_before: case pos
R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
K : Type u_1
inst✝ : DivisionRing K
p : K[X]
hp : p = 0
⊢ (p * C p.leadingCoeff⁻¹).degree = p.degree
state_after: no goals
Theorem: irrational_mul_nat_iff
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [← cast_natCast, irrational_mul_rat_iff, Nat.cast_ne_zero]
state_before: q : ℚ
m : ℤ
n : ℕ
x : ℝ
⊢ Irrational (x * ↑n) ↔ n ≠ 0 ∧ Irrational x
state_after: no goals
Theorem: Multiset.inf_ndunion
File: Mathlib/Data/Multiset/Lattice.lean

tactic: rw [← inf_dedup, dedup_ext.2, inf_dedup, inf_add]
state_before: α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderTop α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ (s₁.ndunion s₂).inf = s₁.inf ⊓ s₂.inf
state_after: α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderTop α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ ∀ (a : α), a ∈ s₁.ndunion s₂ ↔ a ∈ s₁ + s₂

tactic: simp
state_before: α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderTop α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ ∀ (a : α), a ∈ s₁.ndunion s₂ ↔ a ∈ s₁ + s₂
state_after: no goals
Theorem: div_le_iff_of_neg'
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [mul_comm, div_le_iff_of_neg hc]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hc : c < 0
⊢ b / c ≤ a ↔ c * a ≤ b
state_after: no goals
Theorem: Subgroup.characteristic_iff_map_eq
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: simp_rw [map_equiv_eq_comap_symm']
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
⊢ H.Characteristic ↔ ∀ (ϕ : G ≃* G), map ϕ.toMonoidHom H = H
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
⊢ H.Characteristic ↔ ∀ (ϕ : G ≃* G), comap ϕ.symm.toMonoidHom H = H

tactic: exact characteristic_iff_comap_eq.trans ⟨fun h ϕ => h ϕ.symm, fun h ϕ => h ϕ.symm⟩
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
⊢ H.Characteristic ↔ ∀ (ϕ : G ≃* G), comap ϕ.symm.toMonoidHom H = H
state_after: no goals
Theorem: Nat.ofDigits_monotone
File: Mathlib/Data/Nat/Digits.lean

tactic: induction' L with _ _ hi
state_before: n p q : ℕ
L : List ℕ
h : p ≤ q
⊢ ofDigits p L ≤ ofDigits q L
state_after: case nil
n p q : ℕ
h : p ≤ q
⊢ ofDigits p [] ≤ ofDigits q []

case cons
n p q : ℕ
h : p ≤ q
head✝ : ℕ
tail✝ : List ℕ
hi : ofDigits p tail✝ ≤ ofDigits q tail✝
⊢ ofDigits p (head✝ :: tail✝) ≤ ofDigits q (head✝ :: tail✝)

tactic: rfl
state_before: case nil
n p q : ℕ
h : p ≤ q
⊢ ofDigits p [] ≤ ofDigits q []
state_after: no goals

tactic: simp only [ofDigits, cast_id, add_le_add_iff_left]
state_before: case cons
n p q : ℕ
h : p ≤ q
head✝ : ℕ
tail✝ : List ℕ
hi : ofDigits p tail✝ ≤ ofDigits q tail✝
⊢ ofDigits p (head✝ :: tail✝) ≤ ofDigits q (head✝ :: tail✝)
state_after: case cons
n p q : ℕ
h : p ≤ q
head✝ : ℕ
tail✝ : List ℕ
hi : ofDigits p tail✝ ≤ ofDigits q tail✝
⊢ p * ofDigits p tail✝ ≤ q * ofDigits q tail✝

tactic: exact Nat.mul_le_mul h hi
state_before: case cons
n p q : ℕ
h : p ≤ q
head✝ : ℕ
tail✝ : List ℕ
hi : ofDigits p tail✝ ≤ ofDigits q tail✝
⊢ p * ofDigits p tail✝ ≤ q * ofDigits q tail✝
state_after: no goals
Theorem: SimpleGraph.edgeSet_fromEdgeSet
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: ext e
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ (fromEdgeSet s).edgeSet = s \ {e | e.IsDiag}
state_after: case h
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e✝ : Sym2 V
s : Set (Sym2 V)
e : Sym2 V
⊢ e ∈ (fromEdgeSet s).edgeSet ↔ e ∈ s \ {e | e.IsDiag}

tactic: exact Sym2.ind (by simp) e
state_before: case h
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e✝ : Sym2 V
s : Set (Sym2 V)
e : Sym2 V
⊢ e ∈ (fromEdgeSet s).edgeSet ↔ e ∈ s \ {e | e.IsDiag}
state_after: no goals

tactic: simp
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e✝ : Sym2 V
s : Set (Sym2 V)
e : Sym2 V
⊢ ∀ (x y : V), s(x, y) ∈ (fromEdgeSet s).edgeSet ↔ s(x, y) ∈ s \ {e | e.IsDiag}
state_after: no goals
Theorem: Sum.Lex.mono
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

tactic: cases h
state_before: α✝ : Type u_1
r₁ r₂ : α✝ → α✝ → Prop
β✝ : Type u_2
s₁ s₂ : β✝ → β✝ → Prop
x y : α✝ ⊕ β✝
hr : ∀ (a b : α✝), r₁ a b → r₂ a b
hs : ∀ (a b : β✝), s₁ a b → s₂ a b
h : Lex r₁ s₁ x y
⊢ Lex r₂ s₂ x y
state_after: case inl
α✝ : Type u_1
r₁ r₂ : α✝ → α✝ → Prop
β✝ : Type u_2
s₁ s₂ : β✝ → β✝ → Prop
hr : ∀ (a b : α✝), r₁ a b → r₂ a b
hs : ∀ (a b : β✝), s₁ a b → s₂ a b
a₁✝ a₂✝ : α✝
h✝ : r₁ a₁✝ a₂✝
⊢ Lex r₂ s₂ (inl a₁✝) (inl a₂✝)

case inr
α✝ : Type u_1
r₁ r₂ : α✝ → α✝ → Prop
β✝ : Type u_2
s₁ s₂ : β✝ → β✝ → Prop
hr : ∀ (a b : α✝), r₁ a b → r₂ a b
hs : ∀ (a b : β✝), s₁ a b → s₂ a b
b₁✝ b₂✝ : β✝
h✝ : s₁ b₁✝ b₂✝
⊢ Lex r₂ s₂ (inr b₁✝) (inr b₂✝)

case sep
α✝ : Type u_1
r₁ r₂ : α✝ → α✝ → Prop
β✝ : Type u_2
s₁ s₂ : β✝ → β✝ → Prop
hr : ∀ (a b : α✝), r₁ a b → r₂ a b
hs : ∀ (a b : β✝), s₁ a b → s₂ a b
a✝ : α✝
b✝ : β✝
⊢ Lex r₂ s₂ (inl a✝) (inr b✝)

tactic: exact Lex.inl (hr _ _ ‹_›)
state_before: case inl
α✝ : Type u_1
r₁ r₂ : α✝ → α✝ → Prop
β✝ : Type u_2
s₁ s₂ : β✝ → β✝ → Prop
hr : ∀ (a b : α✝), r₁ a b → r₂ a b
hs : ∀ (a b : β✝), s₁ a b → s₂ a b
a₁✝ a₂✝ : α✝
h✝ : r₁ a₁✝ a₂✝
⊢ Lex r₂ s₂ (inl a₁✝) (inl a₂✝)
state_after: no goals

tactic: exact Lex.inr (hs _ _ ‹_›)
state_before: case inr
α✝ : Type u_1
r₁ r₂ : α✝ → α✝ → Prop
β✝ : Type u_2
s₁ s₂ : β✝ → β✝ → Prop
hr : ∀ (a b : α✝), r₁ a b → r₂ a b
hs : ∀ (a b : β✝), s₁ a b → s₂ a b
b₁✝ b₂✝ : β✝
h✝ : s₁ b₁✝ b₂✝
⊢ Lex r₂ s₂ (inr b₁✝) (inr b₂✝)
state_after: no goals

tactic: exact Lex.sep _ _
state_before: case sep
α✝ : Type u_1
r₁ r₂ : α✝ → α✝ → Prop
β✝ : Type u_2
s₁ s₂ : β✝ → β✝ → Prop
hr : ∀ (a b : α✝), r₁ a b → r₂ a b
hs : ∀ (a b : β✝), s₁ a b → s₂ a b
a✝ : α✝
b✝ : β✝
⊢ Lex r₂ s₂ (inl a✝) (inr b✝)
state_after: no goals
Theorem: CochainComplex.HomComplex.δ_comp_zero_cochain
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

tactic: simp only [δ_comp z₁ z₂ (add_zero n₁) m₁ 1 m₁ h₁ h₁ (zero_add 1), one_smul,
  Int.negOnePow_zero]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ : ℤ
z₁ : Cochain F G n₁
z₂ : Cochain G K 0
m₁ : ℤ
h₁ : n₁ + 1 = m₁
⊢ δ n₁ m₁ (z₁.comp z₂ ⋯) = z₁.comp (δ 0 1 z₂) h₁ + (δ n₁ m₁ z₁).comp z₂ ⋯
state_after: no goals
Theorem: IsPrimitiveRoot.iff
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: refine ⟨fun h => ⟨h.pow_eq_one, fun l hl' hl => ?_⟩,
  fun ⟨hζ, hl⟩ => IsPrimitiveRoot.mk_of_lt ζ hk hζ hl⟩
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l : ℕ
ζ : M
f : F
h : IsPrimitiveRoot ζ k
hk : 0 < k
⊢ IsPrimitiveRoot ζ k ↔ ζ ^ k = 1 ∧ ∀ (l : ℕ), 0 < l → l < k → ζ ^ l ≠ 1
state_after: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l✝ : ℕ
ζ : M
f : F
h✝ : IsPrimitiveRoot ζ k
hk : 0 < k
h : IsPrimitiveRoot ζ k
l : ℕ
hl' : 0 < l
hl : l < k
⊢ ζ ^ l ≠ 1

tactic: rw [h.eq_orderOf] at hl
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l✝ : ℕ
ζ : M
f : F
h✝ : IsPrimitiveRoot ζ k
hk : 0 < k
h : IsPrimitiveRoot ζ k
l : ℕ
hl' : 0 < l
hl : l < k
⊢ ζ ^ l ≠ 1
state_after: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l✝ : ℕ
ζ : M
f : F
h✝ : IsPrimitiveRoot ζ k
hk : 0 < k
h : IsPrimitiveRoot ζ k
l : ℕ
hl' : 0 < l
hl : l < orderOf ζ
⊢ ζ ^ l ≠ 1

tactic: exact pow_ne_one_of_lt_orderOf' hl'.ne' hl
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l✝ : ℕ
ζ : M
f : F
h✝ : IsPrimitiveRoot ζ k
hk : 0 < k
h : IsPrimitiveRoot ζ k
l : ℕ
hl' : 0 < l
hl : l < orderOf ζ
⊢ ζ ^ l ≠ 1
state_after: no goals
Theorem: UniformConcaveOn.sub
File: Mathlib/Analysis/Convex/Strong.lean

tactic: simpa using hf.add hg.neg
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a b m : ℝ
x y : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hg : UniformConvexOn s ψ g
⊢ UniformConcaveOn s (φ + ψ) (f - g)
state_after: no goals
Theorem: Rep.unit_iso_comm
File: Mathlib/RepresentationTheory/Rep.lean

tactic: dsimp [unitIsoAddEquiv, ofModuleMonoidAlgebra, toModuleMonoidAlgebra]
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
g : G
x : CoeSort.coe V
⊢ unitIsoAddEquiv ((V.ρ g).toFun x) =
    ((ofModuleMonoidAlgebra.obj (toModuleMonoidAlgebra.obj V)).ρ g).toFun (unitIsoAddEquiv x)
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
g : G
x : CoeSort.coe V
⊢ (RestrictScalars.addEquiv k (MonoidAlgebra k G) V.ρ.asModule).symm (V.ρ.asModuleEquiv.symm ((V.ρ g) x)) =
    ((Representation.ofModule ↑(ModuleCat.of (MonoidAlgebra k G) V.ρ.asModule)) g)
      ((RestrictScalars.addEquiv k (MonoidAlgebra k G) V.ρ.asModule).symm (V.ρ.asModuleEquiv.symm x))

tactic: erw [Representation.asModuleEquiv_symm_map_rho]
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
g : G
x : CoeSort.coe V
⊢ (RestrictScalars.addEquiv k (MonoidAlgebra k G) V.ρ.asModule).symm (V.ρ.asModuleEquiv.symm ((V.ρ g) x)) =
    ((Representation.ofModule ↑(ModuleCat.of (MonoidAlgebra k G) V.ρ.asModule)) g)
      ((RestrictScalars.addEquiv k (MonoidAlgebra k G) V.ρ.asModule).symm (V.ρ.asModuleEquiv.symm x))
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
g : G
x : CoeSort.coe V
⊢ (MonoidAlgebra.of k G) g • V.ρ.asModuleEquiv.symm x =
    ((Representation.ofModule ↑(ModuleCat.of (MonoidAlgebra k G) V.ρ.asModule)) g)
      ((RestrictScalars.addEquiv k (MonoidAlgebra k G) V.ρ.asModule).symm (V.ρ.asModuleEquiv.symm x))

tactic: rfl
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
g : G
x : CoeSort.coe V
⊢ (MonoidAlgebra.of k G) g • V.ρ.asModuleEquiv.symm x =
    ((Representation.ofModule ↑(ModuleCat.of (MonoidAlgebra k G) V.ρ.asModule)) g)
      ((RestrictScalars.addEquiv k (MonoidAlgebra k G) V.ρ.asModule).symm (V.ρ.asModuleEquiv.symm x))
state_after: no goals
Theorem: Inducing.withSeminorms
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: exact f.withSeminorms_induced hq
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕝 : Type u_3
𝕝₂ : Type u_4
E : Type u_5
F : Type u_6
G : Type u_7
ι : Type u_8
ι' : Type u_9
inst✝⁸ : NormedField 𝕜
inst✝⁷ : AddCommGroup E
inst✝⁶ : Module 𝕜 E
inst✝⁵ : NormedField 𝕜₂
inst✝⁴ : AddCommGroup F
inst✝³ : Module 𝕜₂ F
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝² : RingHomIsometric σ₁₂
inst✝¹ : TopologicalSpace F
hι : Nonempty ι
q : SeminormFamily 𝕜₂ F ι
hq : WithSeminorms q
inst✝ : TopologicalSpace E
f : E →ₛₗ[σ₁₂] F
hf : Inducing ⇑f
⊢ WithSeminorms (q.comp f)
state_after: no goals
Theorem: List.findIdxs_eq_map_indexesValues
File: Mathlib/Data/List/Indexes.lean

tactic: simp (config := { unfoldPartialApp := true }) only [indexesValues_eq_filter_enum,
  map_filter_eq_foldr, findIdxs, uncurry, foldrIdx_eq_foldr_enum, decide_eq_true_eq, comp_apply,
  Bool.cond_decide]
state_before: α : Type u
β : Type v
p : α → Prop
inst✝ : DecidablePred p
as : List α
⊢ findIdxs (fun b => decide (p b)) as = map Prod.fst (indexesValues (fun b => decide (p b)) as)
state_after: no goals