1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: QuasilinearOn.monotoneOn_or_antitoneOn
File: Mathlib/Analysis/Convex/Quasiconvex.lean

tactic: simp_rw [monotoneOn_or_antitoneOn_iff_uIcc, ← segment_eq_uIcc]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝¹ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → β
inst✝ : LinearOrder β
hf : QuasilinearOn 𝕜 s f
⊢ MonotoneOn f s ∨ AntitoneOn f s
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝¹ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → β
inst✝ : LinearOrder β
hf : QuasilinearOn 𝕜 s f
⊢ ∀ a ∈ s, ∀ b ∈ s, ∀ c ∈ s, c ∈ segment 𝕜 a b → f c ∈ uIcc (f a) (f b)

tactic: rintro a ha b hb c _ h
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝¹ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → β
inst✝ : LinearOrder β
hf : QuasilinearOn 𝕜 s f
⊢ ∀ a ∈ s, ∀ b ∈ s, ∀ c ∈ s, c ∈ segment 𝕜 a b → f c ∈ uIcc (f a) (f b)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝¹ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → β
inst✝ : LinearOrder β
hf : QuasilinearOn 𝕜 s f
a : 𝕜
ha : a ∈ s
b : 𝕜
hb : b ∈ s
c : 𝕜
a✝ : c ∈ s
h : c ∈ segment 𝕜 a b
⊢ f c ∈ uIcc (f a) (f b)

tactic: refine ⟨((hf.2 _).segment_subset ?_ ?_ h).2, ((hf.1 _).segment_subset ?_ ?_ h).2⟩ <;> simp [*]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝¹ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → β
inst✝ : LinearOrder β
hf : QuasilinearOn 𝕜 s f
a : 𝕜
ha : a ∈ s
b : 𝕜
hb : b ∈ s
c : 𝕜
a✝ : c ∈ s
h : c ∈ segment 𝕜 a b
⊢ f c ∈ uIcc (f a) (f b)
state_after: no goals
Theorem: Nat.Primrec'.mul
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: v : Vector ℕ (Nat.succ 0 + 1)
⊢ Nat.rec 0 (fun y IH => (y ::ᵥ IH ::ᵥ v.tail).tail.tail.head + (y ::ᵥ IH ::ᵥ v.tail).tail.head) v.head =
    v.head * v.tail.head
state_after: v : Vector ℕ (Nat.succ 0 + 1)
⊢ Nat.rec 0 (fun y IH => v.tail.head + IH) v.head = v.head * v.tail.head

tactic: induction v.head <;> simp [*, Nat.succ_mul]
state_before: v : Vector ℕ (Nat.succ 0 + 1)
⊢ Nat.rec 0 (fun y IH => v.tail.head + IH) v.head = v.head * v.tail.head
state_after: case succ
v : Vector ℕ (Nat.succ 0 + 1)
n✝ : ℕ
a✝ : Nat.rec 0 (fun y IH => v.tail.head + IH) n✝ = n✝ * v.tail.head
⊢ v.tail.head + n✝ * v.tail.head = n✝ * v.tail.head + v.tail.head

tactic: rw [add_comm]
state_before: case succ
v : Vector ℕ (Nat.succ 0 + 1)
n✝ : ℕ
a✝ : Nat.rec 0 (fun y IH => v.tail.head + IH) n✝ = n✝ * v.tail.head
⊢ v.tail.head + n✝ * v.tail.head = n✝ * v.tail.head + v.tail.head
state_after: no goals
Theorem: CochainComplex.HomComplex.δ_comp_ofHom
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

tactic: rw [← Cocycle.ofHom_coe, δ_comp_zero_cocycle]
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
f : G ⟶ K
m : ℤ
⊢ δ n m (z₁.comp (Cochain.ofHom f) ⋯) = (δ n m z₁).comp (Cochain.ofHom f) ⋯
state_after: no goals
Theorem: List.splitOnP_eq_single
File: Mathlib/Data/List/Basic.lean

tactic: induction xs with
| nil => rfl
| cons hd tl ih =>
  simp only [splitOnP_cons, h hd (mem_cons_self hd tl), if_neg]
  rw [ih <| forall_mem_of_forall_mem_cons h]
  rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
h : ∀ (x : α), x ∈ xs → ¬p x = true
⊢ splitOnP p xs = [xs]
state_after: no goals

tactic: rfl
state_before: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
h : ∀ (x : α), x ∈ [] → ¬p x = true
⊢ splitOnP p [] = [[]]
state_after: no goals

tactic: simp only [splitOnP_cons, h hd (mem_cons_self hd tl), if_neg]
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
hd : α
tl : List α
ih : (∀ (x : α), x ∈ tl → ¬p x = true) → splitOnP p tl = [tl]
h : ∀ (x : α), x ∈ hd :: tl → ¬p x = true
⊢ splitOnP p (hd :: tl) = [hd :: tl]
state_after: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
hd : α
tl : List α
ih : (∀ (x : α), x ∈ tl → ¬p x = true) → splitOnP p tl = [tl]
h : ∀ (x : α), x ∈ hd :: tl → ¬p x = true
⊢ (if False then [] :: splitOnP p tl else modifyHead (cons hd) (splitOnP p tl)) = [hd :: tl]

tactic: rw [ih <| forall_mem_of_forall_mem_cons h]
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
hd : α
tl : List α
ih : (∀ (x : α), x ∈ tl → ¬p x = true) → splitOnP p tl = [tl]
h : ∀ (x : α), x ∈ hd :: tl → ¬p x = true
⊢ (if False then [] :: splitOnP p tl else modifyHead (cons hd) (splitOnP p tl)) = [hd :: tl]
state_after: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
hd : α
tl : List α
ih : (∀ (x : α), x ∈ tl → ¬p x = true) → splitOnP p tl = [tl]
h : ∀ (x : α), x ∈ hd :: tl → ¬p x = true
⊢ (if False then [[], tl] else modifyHead (cons hd) [tl]) = [hd :: tl]

tactic: rfl
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
hd : α
tl : List α
ih : (∀ (x : α), x ∈ tl → ¬p x = true) → splitOnP p tl = [tl]
h : ∀ (x : α), x ∈ hd :: tl → ¬p x = true
⊢ (if False then [[], tl] else modifyHead (cons hd) [tl]) = [hd :: tl]
state_after: no goals
Theorem: FractionalIdeal.spanSingleton_mul_spanSingleton
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

tactic: apply coeToSubmodule_injective
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x y : P
⊢ spanSingleton S x * spanSingleton S y = spanSingleton S (x * y)
state_after: case a
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x y : P
⊢ (fun I => ↑I) (spanSingleton S x * spanSingleton S y) = (fun I => ↑I) (spanSingleton S (x * y))

tactic: simp only [coe_mul, coe_spanSingleton, span_mul_span, singleton_mul_singleton]
state_before: case a
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x y : P
⊢ (fun I => ↑I) (spanSingleton S x * spanSingleton S y) = (fun I => ↑I) (spanSingleton S (x * y))
state_after: no goals
Theorem: Disjoint.disjoint_sup_left_of_disjoint_sup_right
File: Mathlib/Order/ModularLattice.lean

tactic: rw [disjoint_comm, sup_comm]
state_before: α : Type u_1
a b c : α
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
h : Disjoint b c
hsup : Disjoint a (b ⊔ c)
⊢ Disjoint (a ⊔ b) c
state_after: α : Type u_1
a b c : α
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
h : Disjoint b c
hsup : Disjoint a (b ⊔ c)
⊢ Disjoint c (b ⊔ a)

tactic: apply Disjoint.disjoint_sup_right_of_disjoint_sup_left h.symm
state_before: α : Type u_1
a b c : α
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
h : Disjoint b c
hsup : Disjoint a (b ⊔ c)
⊢ Disjoint c (b ⊔ a)
state_after: α : Type u_1
a b c : α
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
h : Disjoint b c
hsup : Disjoint a (b ⊔ c)
⊢ Disjoint (c ⊔ b) a

tactic: rwa [sup_comm, disjoint_comm] at hsup
state_before: α : Type u_1
a b c : α
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
h : Disjoint b c
hsup : Disjoint a (b ⊔ c)
⊢ Disjoint (c ⊔ b) a
state_after: no goals
Theorem: norm_sum_neg_one_pow_le
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: rw [neg_one_geom_sum]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
b : ℝ
f : ℕ → ℝ
z : ℕ → E
n : ℕ
⊢ ‖∑ i ∈ Finset.range n, (-1) ^ i‖ ≤ 1
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
b : ℝ
f : ℕ → ℝ
z : ℕ → E
n : ℕ
⊢ ‖if Even n then 0 else 1‖ ≤ 1

tactic: split_ifs <;> norm_num
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
b : ℝ
f : ℕ → ℝ
z : ℕ → E
n : ℕ
⊢ ‖if Even n then 0 else 1‖ ≤ 1
state_after: no goals
Theorem: Monotone.map_sSup_of_continuousAt
File: Mathlib/Topology/Order/Monotone.lean

tactic: rcases s.eq_empty_or_nonempty with h | h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁶ : CompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : CompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
s : Set α
Cf : ContinuousAt f (sSup s)
Mf : Monotone f
fbot : f ⊥ = ⊥
⊢ f (sSup s) = sSup (f '' s)
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁶ : CompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : CompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
s : Set α
Cf : ContinuousAt f (sSup s)
Mf : Monotone f
fbot : f ⊥ = ⊥
h : s = ∅
⊢ f (sSup s) = sSup (f '' s)

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁶ : CompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : CompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
s : Set α
Cf : ContinuousAt f (sSup s)
Mf : Monotone f
fbot : f ⊥ = ⊥
h : s.Nonempty
⊢ f (sSup s) = sSup (f '' s)

tactic: simp [h, fbot]
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁶ : CompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : CompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
s : Set α
Cf : ContinuousAt f (sSup s)
Mf : Monotone f
fbot : f ⊥ = ⊥
h : s = ∅
⊢ f (sSup s) = sSup (f '' s)
state_after: no goals

tactic: exact Mf.map_sSup_of_continuousAt' Cf h
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁶ : CompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : CompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
s : Set α
Cf : ContinuousAt f (sSup s)
Mf : Monotone f
fbot : f ⊥ = ⊥
h : s.Nonempty
⊢ f (sSup s) = sSup (f '' s)
state_after: no goals
Theorem: IsCompact.elim_finite_subfamily_closed
File: Mathlib/Topology/Compactness/Compact.lean

tactic: rwa [← iInter_eq_iInter_finset]
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 = ∅
⊢ s ∩ ⋂ i, ⋂ i_1 ∈ i, t i_1 = ∅
state_after: no goals
Theorem: RingSubgroupsBasis.of_comm
File: Mathlib/Topology/Algebra/Nonarchimedean/Bases.lean

tactic: simpa only [mul_comm] using hj
state_before: A✝ : Type u_1
ι✝ : Type u_2
inst✝¹ : Ring A✝
A : Type u_3
ι : Type u_4
inst✝ : CommRing A
B : ι → AddSubgroup A
inter : ∀ (i j : ι), ∃ k, B k ≤ B i ⊓ B j
mul : ∀ (i : ι), ∃ j, ↑(B j) * ↑(B j) ⊆ ↑(B i)
leftMul : ∀ (x : A) (i : ι), ∃ j, ↑(B j) ⊆ (fun y => x * y) ⁻¹' ↑(B i)
x : A
i j : ι
hj : ↑(B j) ⊆ (fun y => x * y) ⁻¹' ↑(B i)
⊢ ↑(B j) ⊆ (fun x_1 => x_1 * x) ⁻¹' ↑(B i)
state_after: no goals
Theorem: Tropical.add_eq_left
File: Mathlib/Algebra/Tropical/Basic.lean

tactic: simpa using h
state_before: R : Type u
inst✝ : LinearOrder R
x y : Tropical R
h : x ≤ y
⊢ untrop (x + y) = untrop x
state_after: no goals
Theorem: Fintype.piFinset_image₂
File: Mathlib/Data/Finset/NAry.lean

tactic: ext
state_before: α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ✝ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
ι : Type u_14
α : ι → Type u_15
β : ι → Type u_16
γ : ι → Type u_17
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
inst✝ : (i : ι) → DecidableEq (γ i)
f : (i : ι) → α i → β i → γ i
s : (i : ι) → Finset (α i)
t : (i : ι) → Finset (β i)
⊢ (piFinset fun i => image₂ (f i) (s i) (t i)) = image₂ (fun a b i => f i (a i) (b i)) (piFinset s) (piFinset t)
state_after: case a
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ✝ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
ι : Type u_14
α : ι → Type u_15
β : ι → Type u_16
γ : ι → Type u_17
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
inst✝ : (i : ι) → DecidableEq (γ i)
f : (i : ι) → α i → β i → γ i
s : (i : ι) → Finset (α i)
t : (i : ι) → Finset (β i)
a✝ : (a : ι) → γ a
⊢ (a✝ ∈ piFinset fun i => image₂ (f i) (s i) (t i)) ↔
    a✝ ∈ image₂ (fun a b i => f i (a i) (b i)) (piFinset s) (piFinset t)

tactic: simp only [mem_piFinset, mem_image₂, Classical.skolem, forall_and, Function.funext_iff]
state_before: case a
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ✝ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
ι : Type u_14
α : ι → Type u_15
β : ι → Type u_16
γ : ι → Type u_17
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
inst✝ : (i : ι) → DecidableEq (γ i)
f : (i : ι) → α i → β i → γ i
s : (i : ι) → Finset (α i)
t : (i : ι) → Finset (β i)
a✝ : (a : ι) → γ a
⊢ (a✝ ∈ piFinset fun i => image₂ (f i) (s i) (t i)) ↔
    a✝ ∈ image₂ (fun a b i => f i (a i) (b i)) (piFinset s) (piFinset t)
state_after: no goals
Theorem: ZMod.val_natCast_of_lt
File: Mathlib/Data/ZMod/Basic.lean

tactic: rwa [val_natCast, Nat.mod_eq_of_lt]
state_before: n a : ℕ
h : a < n
⊢ (↑a).val = a
state_after: no goals
Theorem: ENNReal.toReal_eq_one_iff
File: Mathlib/Data/ENNReal/Basic.lean

tactic: rw [ENNReal.toReal, NNReal.coe_eq_one, ENNReal.toNNReal_eq_one_iff]
state_before: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
⊢ x.toReal = 1 ↔ x = 1
state_after: no goals
Theorem: Ordinal.le_cof_type
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rintro H d ⟨S, h, rfl⟩
state_before: α : Type u_1
r : α → α → Prop
inst✝ : IsWellOrder α r
c : Cardinal.{u_1}
⊢ (∀ (S : Set α), Unbounded r S → c ≤ #↑S) → ∀ b ∈ {c | ∃ S, Unbounded r S ∧ #↑S = c}, c ≤ b
state_after: case intro.intro
α : Type u_1
r : α → α → Prop
inst✝ : IsWellOrder α r
c : Cardinal.{u_1}
H : ∀ (S : Set α), Unbounded r S → c ≤ #↑S
S : Set α
h : Unbounded r S
⊢ c ≤ #↑S

tactic: exact H _ h
state_before: case intro.intro
α : Type u_1
r : α → α → Prop
inst✝ : IsWellOrder α r
c : Cardinal.{u_1}
H : ∀ (S : Set α), Unbounded r S → c ≤ #↑S
S : Set α
h : Unbounded r S
⊢ c ≤ #↑S
state_after: no goals
Theorem: Finset.one_lt_card
File: Mathlib/Data/Finset/Card.lean

tactic: rw [← not_iff_not]
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
⊢ 1 < s.card ↔ ∃ a ∈ s, ∃ b ∈ s, a ≠ b
state_after: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
⊢ ¬1 < s.card ↔ ¬∃ a ∈ s, ∃ b ∈ s, a ≠ b

tactic: push_neg
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
⊢ ¬1 < s.card ↔ ¬∃ a ∈ s, ∃ b ∈ s, a ≠ b
state_after: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
⊢ s.card ≤ 1 ↔ ∀ a ∈ s, ∀ b ∈ s, a = b

tactic: exact card_le_one
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
⊢ s.card ≤ 1 ↔ ∀ a ∈ s, ∀ b ∈ s, a = b
state_after: no goals
Theorem: Int.ModEq.cancel_right_div_gcd
File: Mathlib/Data/Int/ModEq.lean

tactic: letI d := gcd m c
state_before: m n a b c d : ℤ
hm : 0 < m
h : a * c ≡ b * c [ZMOD m]
⊢ a ≡ b [ZMOD m / ↑(m.gcd c)]
state_after: m n a b c d✝ : ℤ
hm : 0 < m
h : a * c ≡ b * c [ZMOD m]
d : ℕ := m.gcd c
⊢ a ≡ b [ZMOD m / ↑(m.gcd c)]

tactic: rw [modEq_iff_dvd] at h ⊢
state_before: m n a b c d✝ : ℤ
hm : 0 < m
h : a * c ≡ b * c [ZMOD m]
d : ℕ := m.gcd c
⊢ a ≡ b [ZMOD m / ↑(m.gcd c)]
state_after: m n a b c d✝ : ℤ
hm : 0 < m
h : m ∣ b * c - a * c
d : ℕ := m.gcd c
⊢ m / ↑(m.gcd c) ∣ b - a

tactic: refine Int.dvd_of_dvd_mul_right_of_gcd_one (?_ : m / d ∣ c / d * (b - a)) ?_
state_before: m n a b c d✝ : ℤ
hm : 0 < m
h : m ∣ b * c - a * c
d : ℕ := m.gcd c
⊢ m / ↑(m.gcd c) ∣ b - a
state_after: case refine_1
m n a b c d✝ : ℤ
hm : 0 < m
h : m ∣ b * c - a * c
d : ℕ := m.gcd c
⊢ m / ↑d ∣ c / ↑d * (b - a)

case refine_2
m n a b c d✝ : ℤ
hm : 0 < m
h : m ∣ b * c - a * c
d : ℕ := m.gcd c
⊢ (m / ↑(m.gcd c)).gcd (c / ↑d) = 1

tactic: rw [mul_comm, ← Int.mul_ediv_assoc (b - a) gcd_dvd_right, sub_mul]
state_before: case refine_1
m n a b c d✝ : ℤ
hm : 0 < m
h : m ∣ b * c - a * c
d : ℕ := m.gcd c
⊢ m / ↑d ∣ c / ↑d * (b - a)
state_after: case refine_1
m n a b c d✝ : ℤ
hm : 0 < m
h : m ∣ b * c - a * c
d : ℕ := m.gcd c
⊢ m / ↑d ∣ (b * c - a * c) / ↑(m.gcd c)

tactic: exact Int.ediv_dvd_ediv gcd_dvd_left h
state_before: case refine_1
m n a b c d✝ : ℤ
hm : 0 < m
h : m ∣ b * c - a * c
d : ℕ := m.gcd c
⊢ m / ↑d ∣ (b * c - a * c) / ↑(m.gcd c)
state_after: no goals

tactic: rw [gcd_div gcd_dvd_left gcd_dvd_right, natAbs_ofNat,
  Nat.div_self (gcd_pos_of_ne_zero_left c hm.ne')]
state_before: case refine_2
m n a b c d✝ : ℤ
hm : 0 < m
h : m ∣ b * c - a * c
d : ℕ := m.gcd c
⊢ (m / ↑(m.gcd c)).gcd (c / ↑d) = 1
state_after: no goals
Theorem: PartialEquiv.symm_symm
File: Mathlib/Logic/Equiv/PartialEquiv.lean

tactic: cases e
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
⊢ e.symm.symm = e
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e' : PartialEquiv β γ
toFun✝ : α → β
invFun✝ : β → α
source✝ : Set α
target✝ : Set β
map_source'✝ : ∀ ⦃x : α⦄, x ∈ source✝ → toFun✝ x ∈ target✝
map_target'✝ : ∀ ⦃x : β⦄, x ∈ target✝ → invFun✝ x ∈ source✝
left_inv'✝ : ∀ ⦃x : α⦄, x ∈ source✝ → invFun✝ (toFun✝ x) = x
right_inv'✝ : ∀ ⦃x : β⦄, x ∈ target✝ → toFun✝ (invFun✝ x) = x
⊢ { toFun := toFun✝, invFun := invFun✝, source := source✝, target := target✝, map_source' := map_source'✝,
          map_target' := map_target'✝, left_inv' := left_inv'✝, right_inv' := right_inv'✝ }.symm.symm =
    { toFun := toFun✝, invFun := invFun✝, source := source✝, target := target✝, map_source' := map_source'✝,
      map_target' := map_target'✝, left_inv' := left_inv'✝, right_inv' := right_inv'✝ }

tactic: rfl
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e' : PartialEquiv β γ
toFun✝ : α → β
invFun✝ : β → α
source✝ : Set α
target✝ : Set β
map_source'✝ : ∀ ⦃x : α⦄, x ∈ source✝ → toFun✝ x ∈ target✝
map_target'✝ : ∀ ⦃x : β⦄, x ∈ target✝ → invFun✝ x ∈ source✝
left_inv'✝ : ∀ ⦃x : α⦄, x ∈ source✝ → invFun✝ (toFun✝ x) = x
right_inv'✝ : ∀ ⦃x : β⦄, x ∈ target✝ → toFun✝ (invFun✝ x) = x
⊢ { toFun := toFun✝, invFun := invFun✝, source := source✝, target := target✝, map_source' := map_source'✝,
          map_target' := map_target'✝, left_inv' := left_inv'✝, right_inv' := right_inv'✝ }.symm.symm =
    { toFun := toFun✝, invFun := invFun✝, source := source✝, target := target✝, map_source' := map_source'✝,
      map_target' := map_target'✝, left_inv' := left_inv'✝, right_inv' := right_inv'✝ }
state_after: no goals
Theorem: Set.Nonempty.subset_preimage_const
File: Mathlib/Data/Set/Image.lean

tactic: rw [← image_subset_iff, hs.image_const, singleton_subset_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
s✝ t✝ s : Set α
hs : s.Nonempty
t : Set β
a : β
⊢ s ⊆ (fun x => a) ⁻¹' t ↔ a ∈ t
state_after: no goals
Theorem: tprod_ne_one_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Order.lean

tactic: rw [Ne, tprod_eq_one_iff hf, not_forall]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝² : CanonicallyOrderedCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f : ι → α
a : α
hf : Multipliable f
⊢ ∏' (i : ι), f i ≠ 1 ↔ ∃ x, f x ≠ 1
state_after: no goals
Theorem: PiNat.mem_cylinder_comm
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: simp [mem_cylinder_iff_eq, eq_comm]
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
⊢ y ∈ cylinder x n ↔ x ∈ cylinder y n
state_after: no goals
Theorem: isClosed_iff_nhds
File: Mathlib/Topology/Basic.lean

tactic: simp_rw [isClosed_iff_clusterPt, ClusterPt, inf_principal_neBot_iff]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ IsClosed s ↔ ∀ (x : X), (∀ U ∈ 𝓝 x, (U ∩ s).Nonempty) → x ∈ s
state_after: no goals
Theorem: CategoryTheory.Limits.biprod.isoProd_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: ext <;> simp [Iso.inv_comp_eq]
state_before: J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
D : Type uD
inst✝² : Category.{uD', uD} D
inst✝¹ : HasZeroMorphisms D
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ (isoProd X Y).inv = lift prod.fst prod.snd
state_after: no goals
Theorem: one_lt_oneLePart
File: Mathlib/Algebra/Order/Group/PosPart.lean

tactic: rwa [oneLePart_eq_self.2 ha.le]
state_before: α : Type u_1
β : Type u_2
inst✝³ : Lattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
ha : 1 < a
⊢ 1 < a⁺ᵐ
state_after: no goals
Theorem: List.mk_mem_sym2_iff
File: Mathlib/Data/List/Sym.lean

tactic: constructor
state_before: α : Type u_1
xs : List α
a b : α
⊢ s(a, b) ∈ xs.sym2 ↔ a ∈ xs ∧ b ∈ xs
state_after: case mp
α : Type u_1
xs : List α
a b : α
⊢ s(a, b) ∈ xs.sym2 → a ∈ xs ∧ b ∈ xs

case mpr
α : Type u_1
xs : List α
a b : α
⊢ a ∈ xs ∧ b ∈ xs → s(a, b) ∈ xs.sym2

tactic: intro h
state_before: case mp
α : Type u_1
xs : List α
a b : α
⊢ s(a, b) ∈ xs.sym2 → a ∈ xs ∧ b ∈ xs
state_after: case mp
α : Type u_1
xs : List α
a b : α
h : s(a, b) ∈ xs.sym2
⊢ a ∈ xs ∧ b ∈ xs

tactic: exact ⟨left_mem_of_mk_mem_sym2 h, right_mem_of_mk_mem_sym2 h⟩
state_before: case mp
α : Type u_1
xs : List α
a b : α
h : s(a, b) ∈ xs.sym2
⊢ a ∈ xs ∧ b ∈ xs
state_after: no goals

tactic: rintro ⟨ha, hb⟩
state_before: case mpr
α : Type u_1
xs : List α
a b : α
⊢ a ∈ xs ∧ b ∈ xs → s(a, b) ∈ xs.sym2
state_after: case mpr.intro
α : Type u_1
xs : List α
a b : α
ha : a ∈ xs
hb : b ∈ xs
⊢ s(a, b) ∈ xs.sym2

tactic: exact mk_mem_sym2 ha hb
state_before: case mpr.intro
α : Type u_1
xs : List α
a b : α
ha : a ∈ xs
hb : b ∈ xs
⊢ s(a, b) ∈ xs.sym2
state_after: no goals
Theorem: Real.Angle.neg_pi_lt_toReal
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: induction θ using Real.Angle.induction_on
state_before: θ : Angle
⊢ -π < θ.toReal
state_after: case h
x✝ : ℝ
⊢ -π < (↑x✝).toReal

tactic: exact left_lt_toIocMod _ _ _
state_before: case h
x✝ : ℝ
⊢ -π < (↑x✝).toReal
state_after: no goals
Theorem: SimpleGraph.Subgraph.deleteVerts_le
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: constructor <;> simp [Set.diff_subset]
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
s : Set V
⊢ G'.deleteVerts s ≤ G'
state_after: no goals
Theorem: Nat.one_lt_div_of_mem_properDivisors
File: Mathlib/NumberTheory/Divisors.lean

tactic: obtain ⟨h_dvd, h_lt⟩ := mem_properDivisors.mp h
state_before: n✝ m n : ℕ
h : m ∈ n.properDivisors
⊢ 1 < n / m
state_after: case intro
n✝ m n : ℕ
h : m ∈ n.properDivisors
h_dvd : m ∣ n
h_lt : m < n
⊢ 1 < n / m

tactic: rwa [Nat.lt_div_iff_mul_lt h_dvd, mul_one]
state_before: case intro
n✝ m n : ℕ
h : m ∈ n.properDivisors
h_dvd : m ∣ n
h_lt : m < n
⊢ 1 < n / m
state_after: no goals