1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: not_monotone_not_antitone_iff_exists_lt_lt
File: Mathlib/Order/Monotone/Basic.lean

tactic: simp_rw [not_monotone_not_antitone_iff_exists_le_le, ← and_assoc]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
x y : α
⊢ ¬Monotone f ∧ ¬Antitone f ↔ ∃ a b c, a < b ∧ b < c ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
x y : α
⊢ (∃ a b c, (a ≤ b ∧ b ≤ c) ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c)) ↔
    ∃ a b c, (a < b ∧ b < c) ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c)

tactic: refine exists₃_congr (fun a b c ↦ and_congr_left <|
  fun h ↦ (Ne.le_iff_lt ?_).and <| Ne.le_iff_lt ?_) <;>
(rintro rfl; simp at h)
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
x y : α
⊢ (∃ a b c, (a ≤ b ∧ b ≤ c) ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c)) ↔
    ∃ a b c, (a < b ∧ b < c) ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c)
state_after: no goals

tactic: rintro rfl
state_before: case refine_2
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
x y a b c : α
h : f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c
⊢ b ≠ c
state_after: case refine_2
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
x y a b : α
h : f a < f b ∧ f b < f b ∨ f b < f a ∧ f b < f b
⊢ False

tactic: simp at h
state_before: case refine_2
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
x y a b : α
h : f a < f b ∧ f b < f b ∨ f b < f a ∧ f b < f b
⊢ False
state_after: no goals
Theorem: ChartedSpace.secondCountable_of_countable_cover
File: Mathlib/Geometry/Manifold/ChartedSpace.lean

tactic: haveI : ∀ x : M, SecondCountableTopology (chartAt H x).source :=
  fun x ↦ (chartAt (H := H) x).secondCountableTopology_source
state_before: H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝³ : TopologicalSpace H
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SecondCountableTopology H
s : Set M
hs : ⋃ x ∈ s, (chartAt H x).source = univ
hsc : s.Countable
⊢ SecondCountableTopology M
state_after: H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝³ : TopologicalSpace H
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SecondCountableTopology H
s : Set M
hs : ⋃ x ∈ s, (chartAt H x).source = univ
hsc : s.Countable
this : ∀ (x : M), SecondCountableTopology ↑(chartAt H x).source
⊢ SecondCountableTopology M

tactic: haveI := hsc.toEncodable
state_before: H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝³ : TopologicalSpace H
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SecondCountableTopology H
s : Set M
hs : ⋃ x ∈ s, (chartAt H x).source = univ
hsc : s.Countable
this : ∀ (x : M), SecondCountableTopology ↑(chartAt H x).source
⊢ SecondCountableTopology M
state_after: H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝³ : TopologicalSpace H
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SecondCountableTopology H
s : Set M
hs : ⋃ x ∈ s, (chartAt H x).source = univ
hsc : s.Countable
this✝ : ∀ (x : M), SecondCountableTopology ↑(chartAt H x).source
this : Encodable ↑s
⊢ SecondCountableTopology M

tactic: rw [biUnion_eq_iUnion] at hs
state_before: H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝³ : TopologicalSpace H
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SecondCountableTopology H
s : Set M
hs : ⋃ x ∈ s, (chartAt H x).source = univ
hsc : s.Countable
this✝ : ∀ (x : M), SecondCountableTopology ↑(chartAt H x).source
this : Encodable ↑s
⊢ SecondCountableTopology M
state_after: H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝³ : TopologicalSpace H
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SecondCountableTopology H
s : Set M
hs : ⋃ x, (chartAt H ↑x).source = univ
hsc : s.Countable
this✝ : ∀ (x : M), SecondCountableTopology ↑(chartAt H x).source
this : Encodable ↑s
⊢ SecondCountableTopology M

tactic: exact secondCountableTopology_of_countable_cover (fun x : s ↦ (chartAt H (x : M)).open_source) hs
state_before: H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝³ : TopologicalSpace H
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SecondCountableTopology H
s : Set M
hs : ⋃ x, (chartAt H ↑x).source = univ
hsc : s.Countable
this✝ : ∀ (x : M), SecondCountableTopology ↑(chartAt H x).source
this : Encodable ↑s
⊢ SecondCountableTopology M
state_after: no goals
Theorem: Set.card_insert
File: Mathlib/Data/Set/Finite.lean

tactic: rw [← card_fintypeInsertOfNotMem s h]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
a : α
s : Set α
inst✝ : Fintype ↑s
h : a ∉ s
d : Fintype ↑(insert a s)
⊢ Fintype.card ↑(insert a s) = Fintype.card ↑s + 1
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
a : α
s : Set α
inst✝ : Fintype ↑s
h : a ∉ s
d : Fintype ↑(insert a s)
⊢ Fintype.card ↑(insert a s) = Fintype.card ↑(insert a s)

tactic: congr
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
a : α
s : Set α
inst✝ : Fintype ↑s
h : a ∉ s
d : Fintype ↑(insert a s)
⊢ Fintype.card ↑(insert a s) = Fintype.card ↑(insert a s)
state_after: case h.e_2.h
α : Type u
β : Type v
ι : Sort w
γ : Type x
a : α
s : Set α
inst✝ : Fintype ↑s
h : a ∉ s
d : Fintype ↑(insert a s)
⊢ d = s.fintypeInsertOfNotMem h

tactic: exact Subsingleton.elim _ _
state_before: case h.e_2.h
α : Type u
β : Type v
ι : Sort w
γ : Type x
a : α
s : Set α
inst✝ : Fintype ↑s
h : a ∉ s
d : Fintype ↑(insert a s)
⊢ d = s.fintypeInsertOfNotMem h
state_after: no goals
Theorem: minpoly.prime
File: Mathlib/FieldTheory/Minpoly/Field.lean

tactic: refine ⟨minpoly.ne_zero hx, not_isUnit A x, ?_⟩
state_before: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
⊢ Prime (minpoly A x)
state_after: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
⊢ ∀ (a b : A[X]), minpoly A x ∣ a * b → minpoly A x ∣ a ∨ minpoly A x ∣ b

tactic: rintro p q ⟨d, h⟩
state_before: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
⊢ ∀ (a b : A[X]), minpoly A x ∣ a * b → minpoly A x ∣ a ∨ minpoly A x ∣ b
state_after: case intro
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
p q d : A[X]
h : p * q = minpoly A x * d
⊢ minpoly A x ∣ p ∨ minpoly A x ∣ q

tactic: have : Polynomial.aeval x (p * q) = 0 := by simp [h, aeval A x]
state_before: case intro
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
p q d : A[X]
h : p * q = minpoly A x * d
⊢ minpoly A x ∣ p ∨ minpoly A x ∣ q
state_after: case intro
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
p q d : A[X]
h : p * q = minpoly A x * d
this : (Polynomial.aeval x) (p * q) = 0
⊢ minpoly A x ∣ p ∨ minpoly A x ∣ q

tactic: replace : Polynomial.aeval x p = 0 ∨ Polynomial.aeval x q = 0 := by simpa
state_before: case intro
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
p q d : A[X]
h : p * q = minpoly A x * d
this : (Polynomial.aeval x) (p * q) = 0
⊢ minpoly A x ∣ p ∨ minpoly A x ∣ q
state_after: case intro
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
p q d : A[X]
h : p * q = minpoly A x * d
this : (Polynomial.aeval x) p = 0 ∨ (Polynomial.aeval x) q = 0
⊢ minpoly A x ∣ p ∨ minpoly A x ∣ q

tactic: exact Or.imp (dvd A x) (dvd A x) this
state_before: case intro
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
p q d : A[X]
h : p * q = minpoly A x * d
this : (Polynomial.aeval x) p = 0 ∨ (Polynomial.aeval x) q = 0
⊢ minpoly A x ∣ p ∨ minpoly A x ∣ q
state_after: no goals

tactic: simp [h, aeval A x]
state_before: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
p q d : A[X]
h : p * q = minpoly A x * d
⊢ (Polynomial.aeval x) (p * q) = 0
state_after: no goals

tactic: simpa
state_before: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
p q d : A[X]
h : p * q = minpoly A x * d
this : (Polynomial.aeval x) (p * q) = 0
⊢ (Polynomial.aeval x) p = 0 ∨ (Polynomial.aeval x) q = 0
state_after: no goals
Theorem: IsGroupHom.image_subgroup
File: Mathlib/Deprecated/Subgroup.lean

tactic: simp [eq₁, eq₂, hf.map_mul]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁✝ a₂✝ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set G
hs : IsSubgroup s
a₁ a₂ : H
x✝¹ : a₁ ∈ f '' s
x✝ : a₂ ∈ f '' s
b₁ : G
hb₁ : b₁ ∈ s
eq₁ : f b₁ = a₁
b₂ : G
hb₂ : b₂ ∈ s
eq₂ : f b₂ = a₂
⊢ f (b₁ * b₂) = a₁ * a₂
state_after: no goals

tactic: rw [hf.map_inv]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set G
hs : IsSubgroup s
a : H
x✝ : a ∈ f '' s
b : G
hb : b ∈ s
Eq : f b = a
⊢ f b⁻¹ = a⁻¹
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set G
hs : IsSubgroup s
a : H
x✝ : a ∈ f '' s
b : G
hb : b ∈ s
Eq : f b = a
⊢ (f b)⁻¹ = a⁻¹

tactic: simp [*]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set G
hs : IsSubgroup s
a : H
x✝ : a ∈ f '' s
b : G
hb : b ∈ s
Eq : f b = a
⊢ (f b)⁻¹ = a⁻¹
state_after: no goals
Theorem: DFinsupp.inner_sum
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp (config := { contextual := true }) only [DFinsupp.sum, _root_.inner_sum, smul_eq_mul]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
ι : Type u_4
inst✝² : DecidableEq ι
α : ι → Type u_5
inst✝¹ : (i : ι) → AddZeroClass (α i)
inst✝ : (i : ι) → (x : α i) → Decidable (x ≠ 0)
f : (i : ι) → α i → E
l : Π₀ (i : ι), α i
x : E
⊢ ⟪x, l.sum f⟫_𝕜 = l.sum fun i a => ⟪x, f i a⟫_𝕜
state_after: no goals
Theorem: Nat.ceil_zero
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← Nat.cast_zero, ceil_natCast]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
⊢ ⌈0⌉₊ = 0
state_after: no goals
Theorem: Nat.maxPowDiv.go_succ
File: Mathlib/Data/Nat/MaxPowDiv.lean

tactic: induction k, p, n using go.induct
state_before: k p n : ℕ
⊢ go (k + 1) p n = go k p n + 1
state_after: case case1
k✝ p✝ n✝ : ℕ
h✝ : 1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0
ih1✝ : go (k✝ + 1 + 1) p✝ (n✝ / p✝) = go (k✝ + 1) p✝ (n✝ / p✝) + 1
⊢ go (k✝ + 1) p✝ n✝ = go k✝ p✝ n✝ + 1

case case2
k✝ p✝ n✝ : ℕ
h✝ : ¬(1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0)
⊢ go (k✝ + 1) p✝ n✝ = go k✝ p✝ n✝ + 1

tactic: case case1 h ih =>
  unfold go
  simp only [if_pos h]
  exact ih
state_before: case case1
k✝ p✝ n✝ : ℕ
h✝ : 1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0
ih1✝ : go (k✝ + 1 + 1) p✝ (n✝ / p✝) = go (k✝ + 1) p✝ (n✝ / p✝) + 1
⊢ go (k✝ + 1) p✝ n✝ = go k✝ p✝ n✝ + 1

case case2
k✝ p✝ n✝ : ℕ
h✝ : ¬(1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0)
⊢ go (k✝ + 1) p✝ n✝ = go k✝ p✝ n✝ + 1
state_after: case case2
k✝ p✝ n✝ : ℕ
h✝ : ¬(1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0)
⊢ go (k✝ + 1) p✝ n✝ = go k✝ p✝ n✝ + 1

tactic: case case2 h =>
  unfold go
  simp only [if_neg h]
state_before: case case2
k✝ p✝ n✝ : ℕ
h✝ : ¬(1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0)
⊢ go (k✝ + 1) p✝ n✝ = go k✝ p✝ n✝ + 1
state_after: no goals

tactic: unfold go
state_before: k✝ p✝ n✝ : ℕ
h : 1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0
ih : go (k✝ + 1 + 1) p✝ (n✝ / p✝) = go (k✝ + 1) p✝ (n✝ / p✝) + 1
⊢ go (k✝ + 1) p✝ n✝ = go k✝ p✝ n✝ + 1
state_after: k✝ p✝ n✝ : ℕ
h : 1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0
ih : go (k✝ + 1 + 1) p✝ (n✝ / p✝) = go (k✝ + 1) p✝ (n✝ / p✝) + 1
⊢ (if 1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0 then go (k✝ + 1 + 1) p✝ (n✝ / p✝) else k✝ + 1) =
    (if 1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0 then go (k✝ + 1) p✝ (n✝ / p✝) else k✝) + 1

tactic: simp only [if_pos h]
state_before: k✝ p✝ n✝ : ℕ
h : 1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0
ih : go (k✝ + 1 + 1) p✝ (n✝ / p✝) = go (k✝ + 1) p✝ (n✝ / p✝) + 1
⊢ (if 1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0 then go (k✝ + 1 + 1) p✝ (n✝ / p✝) else k✝ + 1) =
    (if 1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0 then go (k✝ + 1) p✝ (n✝ / p✝) else k✝) + 1
state_after: k✝ p✝ n✝ : ℕ
h : 1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0
ih : go (k✝ + 1 + 1) p✝ (n✝ / p✝) = go (k✝ + 1) p✝ (n✝ / p✝) + 1
⊢ go (k✝ + 1 + 1) p✝ (n✝ / p✝) = go (k✝ + 1) p✝ (n✝ / p✝) + 1

tactic: exact ih
state_before: k✝ p✝ n✝ : ℕ
h : 1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0
ih : go (k✝ + 1 + 1) p✝ (n✝ / p✝) = go (k✝ + 1) p✝ (n✝ / p✝) + 1
⊢ go (k✝ + 1 + 1) p✝ (n✝ / p✝) = go (k✝ + 1) p✝ (n✝ / p✝) + 1
state_after: no goals

tactic: unfold go
state_before: k✝ p✝ n✝ : ℕ
h : ¬(1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0)
⊢ go (k✝ + 1) p✝ n✝ = go k✝ p✝ n✝ + 1
state_after: k✝ p✝ n✝ : ℕ
h : ¬(1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0)
⊢ (if 1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0 then go (k✝ + 1 + 1) p✝ (n✝ / p✝) else k✝ + 1) =
    (if 1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0 then go (k✝ + 1) p✝ (n✝ / p✝) else k✝) + 1

tactic: simp only [if_neg h]
state_before: k✝ p✝ n✝ : ℕ
h : ¬(1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0)
⊢ (if 1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0 then go (k✝ + 1 + 1) p✝ (n✝ / p✝) else k✝ + 1) =
    (if 1 < p✝ ∧ 0 < n✝ ∧ n✝ % p✝ = 0 then go (k✝ + 1) p✝ (n✝ / p✝) else k✝) + 1
state_after: no goals
Theorem: CategoryTheory.SimplicialObject.δ_comp_σ_of_gt
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ, σ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : j.castSucc < i
⊢ X.σ j.castSucc ≫ X.δ i.succ = X.δ i ≫ X.σ j
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : j.castSucc < i
⊢ X.map (SimplexCategory.σ j.castSucc).op ≫ X.map (SimplexCategory.δ i.succ).op =
    X.map (SimplexCategory.δ i).op ≫ X.map (SimplexCategory.σ j).op

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_σ_of_gt H]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : j.castSucc < i
⊢ X.map (SimplexCategory.σ j.castSucc).op ≫ X.map (SimplexCategory.δ i.succ).op =
    X.map (SimplexCategory.δ i).op ≫ X.map (SimplexCategory.σ j).op
state_after: no goals
Theorem: Set.subset_image_diff
File: Mathlib/Data/Set/Image.lean

tactic: rw [diff_subset_iff, ← image_union, union_diff_self]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t✝ : Set α
f : α → β
s t : Set α
⊢ f '' s \ f '' t ⊆ f '' (s \ t)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t✝ : Set α
f : α → β
s t : Set α
⊢ f '' s ⊆ f '' (t ∪ s)

tactic: exact image_subset f subset_union_right
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t✝ : Set α
f : α → β
s t : Set α
⊢ f '' s ⊆ f '' (t ∪ s)
state_after: no goals
Theorem: Set.pi_eq_empty_iff'
File: Mathlib/Data/Set/Prod.lean

tactic: simp [pi_eq_empty_iff]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : ∀ (i : ι), Nonempty (α i)
⊢ s.pi t = ∅ ↔ ∃ i ∈ s, t i = ∅
state_after: no goals
Theorem: Set.Nat.card_coe_set_eq
File: Mathlib/Data/Set/Card.lean

tactic: obtain (h | h) := s.finite_or_infinite
state_before: α : Type u_1
β : Type u_2
s✝ t s : Set α
⊢ Nat.card ↑s = s.ncard
state_after: case inl
α : Type u_1
β : Type u_2
s✝ t s : Set α
h : s.Finite
⊢ Nat.card ↑s = s.ncard

case inr
α : Type u_1
β : Type u_2
s✝ t s : Set α
h : s.Infinite
⊢ Nat.card ↑s = s.ncard

tactic: have := infinite_coe_iff.2 h
state_before: case inr
α : Type u_1
β : Type u_2
s✝ t s : Set α
h : s.Infinite
⊢ Nat.card ↑s = s.ncard
state_after: case inr
α : Type u_1
β : Type u_2
s✝ t s : Set α
h : s.Infinite
this : Infinite ↑s
⊢ Nat.card ↑s = s.ncard

tactic: rw [ncard, h.encard_eq, Nat.card_eq_zero_of_infinite, ENat.toNat_top]
state_before: case inr
α : Type u_1
β : Type u_2
s✝ t s : Set α
h : s.Infinite
this : Infinite ↑s
⊢ Nat.card ↑s = s.ncard
state_after: no goals

tactic: have := h.fintype
state_before: case inl
α : Type u_1
β : Type u_2
s✝ t s : Set α
h : s.Finite
⊢ Nat.card ↑s = s.ncard
state_after: case inl
α : Type u_1
β : Type u_2
s✝ t s : Set α
h : s.Finite
this : Fintype ↑s
⊢ Nat.card ↑s = s.ncard

tactic: rw [ncard, h.encard_eq_coe_toFinset_card, Nat.card_eq_fintype_card,
  toFinite_toFinset, toFinset_card, ENat.toNat_coe]
state_before: case inl
α : Type u_1
β : Type u_2
s✝ t s : Set α
h : s.Finite
this : Fintype ↑s
⊢ Nat.card ↑s = s.ncard
state_after: no goals
Theorem: Multiset.map_add_left_Ico
File: Mathlib/Algebra/Order/Interval/Multiset.lean

tactic: classical rw [Ico, Ico, ← Finset.image_add_left_Ico, Finset.image_val,
    ((Finset.nodup _).map <| add_right_injective c).dedup]
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => c + x) (Ico a b) = Ico (c + a) (c + b)
state_after: no goals

tactic: rw [Ico, Ico, ← Finset.image_add_left_Ico, Finset.image_val,
((Finset.nodup _).map <| add_right_injective c).dedup]
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => c + x) (Ico a b) = Ico (c + a) (c + b)
state_after: no goals
Theorem: SimpleGraph.hasse_preconnected_of_succ
File: Mathlib/Combinatorics/SimpleGraph/Hasse.lean

tactic: rw [reachable_iff_reflTransGen]
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
⊢ (hasse α).Reachable a b
state_after: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
⊢ ReflTransGen (hasse α).Adj a b

tactic: exact
  reflTransGen_of_succ _ (fun c hc => Or.inl <| covBy_succ_of_not_isMax hc.2.not_isMax)
    fun c hc => Or.inr <| covBy_succ_of_not_isMax hc.2.not_isMax
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
⊢ ReflTransGen (hasse α).Adj a b
state_after: no goals
Theorem: Affine.Simplex.dist_circumcenter_sq_eq_sq_sub_circumradius
File: Mathlib/Geometry/Euclidean/Circumcenter.lean

tactic: rw [dist_comm, ← h₁ 0,
  s.dist_sq_eq_dist_orthogonalProjection_sq_add_dist_orthogonalProjection_sq p₁ h]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
r : ℝ
s : Simplex ℝ P n
p₁ : P
h₁ : ∀ (i : Fin (n + 1)), dist (s.points i) p₁ = r
h₁' : ↑(s.orthogonalProjectionSpan p₁) = s.circumcenter
h : s.points 0 ∈ affineSpan ℝ (Set.range s.points)
⊢ dist p₁ s.circumcenter * dist p₁ s.circumcenter = r * r - s.circumradius * s.circumradius
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
r : ℝ
s : Simplex ℝ P n
p₁ : P
h₁ : ∀ (i : Fin (n + 1)), dist (s.points i) p₁ = r
h₁' : ↑(s.orthogonalProjectionSpan p₁) = s.circumcenter
h : s.points 0 ∈ affineSpan ℝ (Set.range s.points)
⊢ dist s.circumcenter p₁ * dist s.circumcenter p₁ =
    dist (s.points 0) ↑(s.orthogonalProjectionSpan p₁) * dist (s.points 0) ↑(s.orthogonalProjectionSpan p₁) +
        dist p₁ ↑(s.orthogonalProjectionSpan p₁) * dist p₁ ↑(s.orthogonalProjectionSpan p₁) -
      s.circumradius * s.circumradius

tactic: simp only [h₁', dist_comm p₁, add_sub_cancel_left, Simplex.dist_circumcenter_eq_circumradius]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
r : ℝ
s : Simplex ℝ P n
p₁ : P
h₁ : ∀ (i : Fin (n + 1)), dist (s.points i) p₁ = r
h₁' : ↑(s.orthogonalProjectionSpan p₁) = s.circumcenter
h : s.points 0 ∈ affineSpan ℝ (Set.range s.points)
⊢ dist s.circumcenter p₁ * dist s.circumcenter p₁ =
    dist (s.points 0) ↑(s.orthogonalProjectionSpan p₁) * dist (s.points 0) ↑(s.orthogonalProjectionSpan p₁) +
        dist p₁ ↑(s.orthogonalProjectionSpan p₁) * dist p₁ ↑(s.orthogonalProjectionSpan p₁) -
      s.circumradius * s.circumradius
state_after: no goals
Theorem: Polynomial.zero_comp
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: rw [← C_0, C_comp]
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]
⊢ comp 0 p = 0
state_after: no goals
Theorem: nnnorm_pow_le'
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simp only [pow_one, le_rfl]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : SeminormedRing α
a : α
x✝ : 0 < 1
⊢ ‖a ^ 1‖₊ ≤ ‖a‖₊ ^ 1
state_after: no goals

tactic: simpa only [pow_succ' _ (n + 1)] using
  le_trans (nnnorm_mul_le _ _) (mul_le_mul_left' (nnnorm_pow_le' a n.succ_pos) _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : SeminormedRing α
a : α
n : ℕ
x✝ : 0 < n + 2
⊢ ‖a ^ (n + 2)‖₊ ≤ ‖a‖₊ ^ (n + 2)
state_after: no goals