1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: SimpleGraph.IsSRGWith.card_neighborFinset_union_eq
File: Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean

tactic: apply Nat.add_right_cancel (m := Fintype.card (G.commonNeighbors v w))
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - Fintype.card ↑(G.commonNeighbors v w)
state_after: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card + Fintype.card ↑(G.commonNeighbors v w) =
    2 * k - Fintype.card ↑(G.commonNeighbors v w) + Fintype.card ↑(G.commonNeighbors v w)

tactic: rw [Nat.sub_add_cancel, ← Set.toFinset_card]
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card + Fintype.card ↑(G.commonNeighbors v w) =
    2 * k - Fintype.card ↑(G.commonNeighbors v w) + Fintype.card ↑(G.commonNeighbors v w)
state_after: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card + (G.commonNeighbors v w).toFinset.card = 2 * k

V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
⊢ Fintype.card ↑(G.commonNeighbors v w) ≤ 2 * k

tactic: simp [commonNeighbors, @Set.toFinset_inter _ _ _ _ _ _ (_),
  ← neighborFinset_def, Finset.card_union_add_card_inter, card_neighborFinset_eq_degree,
  h.regular.degree_eq, two_mul]
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card + (G.commonNeighbors v w).toFinset.card = 2 * k
state_after: no goals

tactic: apply le_trans (card_commonNeighbors_le_degree_left _ _ _)
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
⊢ Fintype.card ↑(G.commonNeighbors v w) ≤ 2 * k
state_after: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
⊢ G.degree v ≤ 2 * k

tactic: simp [h.regular.degree_eq, two_mul]
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
⊢ G.degree v ≤ 2 * k
state_after: no goals
Theorem: Real.log_le_rpow_div
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rcases hx.eq_or_lt with rfl | h
state_before: x✝ y z : ℝ
n : ℕ
x ε : ℝ
hx : 0 ≤ x
hε : 0 < ε
⊢ log x ≤ x ^ ε / ε
state_after: case inl
x y z : ℝ
n : ℕ
ε : ℝ
hε : 0 < ε
hx : 0 ≤ 0
⊢ log 0 ≤ 0 ^ ε / ε

case inr
x✝ y z : ℝ
n : ℕ
x ε : ℝ
hx : 0 ≤ x
hε : 0 < ε
h : 0 < x
⊢ log x ≤ x ^ ε / ε

tactic: rw [le_div_iff' hε]
state_before: case inr
x✝ y z : ℝ
n : ℕ
x ε : ℝ
hx : 0 ≤ x
hε : 0 < ε
h : 0 < x
⊢ log x ≤ x ^ ε / ε
state_after: case inr
x✝ y z : ℝ
n : ℕ
x ε : ℝ
hx : 0 ≤ x
hε : 0 < ε
h : 0 < x
⊢ ε * log x ≤ x ^ ε

tactic: exact (log_rpow h ε).symm.trans_le <| (log_le_sub_one_of_pos <| rpow_pos_of_pos h ε).trans
  (sub_one_lt _).le
state_before: case inr
x✝ y z : ℝ
n : ℕ
x ε : ℝ
hx : 0 ≤ x
hε : 0 < ε
h : 0 < x
⊢ ε * log x ≤ x ^ ε
state_after: no goals

tactic: rw [log_zero, zero_rpow hε.ne', zero_div]
state_before: case inl
x y z : ℝ
n : ℕ
ε : ℝ
hε : 0 < ε
hx : 0 ≤ 0
⊢ log 0 ≤ 0 ^ ε / ε
state_after: no goals
Theorem: Finset.insert_subset_insert_iff
File: Mathlib/Data/Finset/Basic.lean

tactic: simp_rw [← coe_subset]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
ha : a ∉ s
⊢ insert a s ⊆ insert a t ↔ s ⊆ t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
ha : a ∉ s
⊢ ↑(insert a s) ⊆ ↑(insert a t) ↔ ↑s ⊆ ↑t

tactic: simp [-coe_subset, ha]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
ha : a ∉ s
⊢ ↑(insert a s) ⊆ ↑(insert a t) ↔ ↑s ⊆ ↑t
state_after: no goals
Theorem: JoinedIn.symm
File: Mathlib/Topology/Connected/PathConnected.lean

tactic: cases' h.mem with hx hy
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
h : JoinedIn F x y
⊢ JoinedIn F y x
state_after: case intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
h : JoinedIn F x y
hx : x ∈ F
hy : y ∈ F
⊢ JoinedIn F y x

tactic: simp_all [joinedIn_iff_joined]
state_before: case intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
h : JoinedIn F x y
hx : x ∈ F
hy : y ∈ F
⊢ JoinedIn F y x
state_after: case intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
hx✝ : x ∈ F
hy✝ : y ∈ F
h : Joined ⟨x, ⋯⟩ ⟨y, ⋯⟩
hx : x ∈ F
hy : y ∈ F
⊢ Joined ⟨y, ⋯⟩ ⟨x, ⋯⟩

tactic: exact h.symm
state_before: case intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
hx✝ : x ∈ F
hy✝ : y ∈ F
h : Joined ⟨x, ⋯⟩ ⟨y, ⋯⟩
hx : x ∈ F
hy : y ∈ F
⊢ Joined ⟨y, ⋯⟩ ⟨x, ⋯⟩
state_after: no goals
Theorem: AlgebraicGeometry.quasiCompact_iff_forall_affine
File: Mathlib/AlgebraicGeometry/Morphisms/QuasiCompact.lean

tactic: rw [quasiCompact_iff]
state_before: X Y : Scheme
f : X ⟶ Y
⊢ QuasiCompact f ↔ ∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact ↑(f ⁻¹ᵁ U)
state_after: X Y : Scheme
f : X ⟶ Y
⊢ (∀ (U : Set ↑↑Y.toPresheafedSpace), IsOpen U → IsCompact U → IsCompact (⇑f.val.base ⁻¹' U)) ↔
    ∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact ↑(f ⁻¹ᵁ U)

tactic: refine ⟨fun H U hU => H U U.isOpen hU.isCompact, ?_⟩
state_before: X Y : Scheme
f : X ⟶ Y
⊢ (∀ (U : Set ↑↑Y.toPresheafedSpace), IsOpen U → IsCompact U → IsCompact (⇑f.val.base ⁻¹' U)) ↔
    ∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact ↑(f ⁻¹ᵁ U)
state_after: X Y : Scheme
f : X ⟶ Y
⊢ (∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact ↑(f ⁻¹ᵁ U)) →
    ∀ (U : Set ↑↑Y.toPresheafedSpace), IsOpen U → IsCompact U → IsCompact (⇑f.val.base ⁻¹' U)

tactic: intro H U hU hU'
state_before: X Y : Scheme
f : X ⟶ Y
⊢ (∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact ↑(f ⁻¹ᵁ U)) →
    ∀ (U : Set ↑↑Y.toPresheafedSpace), IsOpen U → IsCompact U → IsCompact (⇑f.val.base ⁻¹' U)
state_after: X Y : Scheme
f : X ⟶ Y
H : ∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact ↑(f ⁻¹ᵁ U)
U : Set ↑↑Y.toPresheafedSpace
hU : IsOpen U
hU' : IsCompact U
⊢ IsCompact (⇑f.val.base ⁻¹' U)

tactic: obtain ⟨S, hS, rfl⟩ := (isCompactOpen_iff_eq_finset_affine_union U).mp ⟨hU', hU⟩
state_before: X Y : Scheme
f : X ⟶ Y
H : ∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact ↑(f ⁻¹ᵁ U)
U : Set ↑↑Y.toPresheafedSpace
hU : IsOpen U
hU' : IsCompact U
⊢ IsCompact (⇑f.val.base ⁻¹' U)
state_after: case intro.intro
X Y : Scheme
f : X ⟶ Y
H : ∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact ↑(f ⁻¹ᵁ U)
S : Set ↑Y.affineOpens
hS : S.Finite
hU : IsOpen (⋃ i ∈ S, ↑↑i)
hU' : IsCompact (⋃ i ∈ S, ↑↑i)
⊢ IsCompact (⇑f.val.base ⁻¹' ⋃ i ∈ S, ↑↑i)

tactic: simp only [Set.preimage_iUnion]
state_before: case intro.intro
X Y : Scheme
f : X ⟶ Y
H : ∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact ↑(f ⁻¹ᵁ U)
S : Set ↑Y.affineOpens
hS : S.Finite
hU : IsOpen (⋃ i ∈ S, ↑↑i)
hU' : IsCompact (⋃ i ∈ S, ↑↑i)
⊢ IsCompact (⇑f.val.base ⁻¹' ⋃ i ∈ S, ↑↑i)
state_after: case intro.intro
X Y : Scheme
f : X ⟶ Y
H : ∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact ↑(f ⁻¹ᵁ U)
S : Set ↑Y.affineOpens
hS : S.Finite
hU : IsOpen (⋃ i ∈ S, ↑↑i)
hU' : IsCompact (⋃ i ∈ S, ↑↑i)
⊢ IsCompact (⋃ i ∈ S, ⇑f.val.base ⁻¹' ↑↑i)

tactic: exact Set.Finite.isCompact_biUnion hS (fun i _ => H i i.prop)
state_before: case intro.intro
X Y : Scheme
f : X ⟶ Y
H : ∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact ↑(f ⁻¹ᵁ U)
S : Set ↑Y.affineOpens
hS : S.Finite
hU : IsOpen (⋃ i ∈ S, ↑↑i)
hU' : IsCompact (⋃ i ∈ S, ↑↑i)
⊢ IsCompact (⋃ i ∈ S, ⇑f.val.base ⁻¹' ↑↑i)
state_after: no goals
Theorem: IsCompact.compl_mem_sets
File: Mathlib/Topology/Compactness/Compact.lean

tactic: contrapose! hf
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsCompact s
f : Filter X
hf : ∀ x ∈ s, sᶜ ∈ 𝓝 x ⊓ f
⊢ sᶜ ∈ f
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsCompact s
f : Filter X
hf : sᶜ ∉ f
⊢ ∃ x ∈ s, sᶜ ∉ 𝓝 x ⊓ f

tactic: simp only [not_mem_iff_inf_principal_compl, compl_compl, inf_assoc] at hf ⊢
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsCompact s
f : Filter X
hf : sᶜ ∉ f
⊢ ∃ x ∈ s, sᶜ ∉ 𝓝 x ⊓ f
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsCompact s
f : Filter X
hf : (f ⊓ 𝓟 s).NeBot
⊢ ∃ x ∈ s, (𝓝 x ⊓ (f ⊓ 𝓟 s)).NeBot

tactic: exact @hs _ hf inf_le_right
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsCompact s
f : Filter X
hf : (f ⊓ 𝓟 s).NeBot
⊢ ∃ x ∈ s, (𝓝 x ⊓ (f ⊓ 𝓟 s)).NeBot
state_after: no goals
Theorem: List.rel_nodup
File: Mathlib/Data/List/Nodup.lean

tactic: simp only [nodup_nil]
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r✝ : α → α → Prop
a b : α
r : α → β → Prop
hr : Relator.BiUnique r
⊢ (fun x x_1 => x ↔ x_1) [].Nodup [].Nodup
state_after: no goals

tactic: simpa only [nodup_cons] using
  Relator.rel_and (Relator.rel_not (rel_mem hr hab h)) (rel_nodup hr h)
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r✝ : α → α → Prop
a b : α
r : α → β → Prop
hr : Relator.BiUnique r
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
hab : r a✝ b✝
h : Forall₂ r l₁✝ l₂✝
⊢ (fun x x_1 => x ↔ x_1) (a✝ :: l₁✝).Nodup (b✝ :: l₂✝).Nodup
state_after: no goals
Theorem: Finset.memberSubfamily_image_erase
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

tactic: simp [eq_empty_iff_forall_not_mem,
  (ne_of_mem_of_not_mem' (mem_insert_self _ _) (not_mem_erase _ _)).symm]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
⊢ memberSubfamily a (image (fun x => x.erase a) 𝒜) = ∅
state_after: no goals
Theorem: ComputablePred.computable_iff
File: Mathlib/Computability/Halting.lean

tactic: rintro ⟨f, h, rfl⟩
state_before: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
p : α → Prop
⊢ (∃ f, Computable f ∧ p = fun a => f a = true) → ComputablePred p
state_after: case intro.intro
α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
h : Computable f
⊢ ComputablePred fun a => f a = true

tactic: exact ⟨by infer_instance, by simpa using h⟩
state_before: case intro.intro
α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
h : Computable f
⊢ ComputablePred fun a => f a = true
state_after: no goals

tactic: infer_instance
state_before: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
h : Computable f
⊢ DecidablePred fun a => f a = true
state_after: no goals

tactic: simpa using h
state_before: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
h : Computable f
⊢ Computable fun a => decide ((fun a => f a = true) a)
state_after: no goals
Theorem: Nat.ne_one_iff_exists_prime_dvd
File: Mathlib/Data/Nat/Prime.lean

tactic: simpa using Exists.intro 2 Nat.prime_two
state_before: n : ℕ
⊢ 0 ≠ 1 ↔ ∃ p, Prime p ∧ p ∣ 0
state_after: no goals

tactic: simp [Nat.not_prime_one]
state_before: n : ℕ
⊢ 1 ≠ 1 ↔ ∃ p, Prime p ∧ p ∣ 1
state_after: no goals

tactic: let a := n + 2
state_before: n✝ n : ℕ
⊢ n + 2 ≠ 1 ↔ ∃ p, Prime p ∧ p ∣ n + 2
state_after: n✝ n : ℕ
a : ℕ := n + 2
⊢ n + 2 ≠ 1 ↔ ∃ p, Prime p ∧ p ∣ n + 2

tactic: let ha : a ≠ 1 := Nat.succ_succ_ne_one n
state_before: n✝ n : ℕ
a : ℕ := n + 2
⊢ n + 2 ≠ 1 ↔ ∃ p, Prime p ∧ p ∣ n + 2
state_after: n✝ n : ℕ
a : ℕ := n + 2
ha : a ≠ 1 := succ_succ_ne_one n
⊢ n + 2 ≠ 1 ↔ ∃ p, Prime p ∧ p ∣ n + 2

tactic: simp only [true_iff_iff, Ne, not_false_iff, ha]
state_before: n✝ n : ℕ
a : ℕ := n + 2
ha : a ≠ 1 := succ_succ_ne_one n
⊢ n + 2 ≠ 1 ↔ ∃ p, Prime p ∧ p ∣ n + 2
state_after: n✝ n : ℕ
a : ℕ := n + 2
ha : a ≠ 1 := succ_succ_ne_one n
⊢ ∃ p, Prime p ∧ p ∣ n + 2

tactic: exact ⟨a.minFac, Nat.minFac_prime ha, a.minFac_dvd⟩
state_before: n✝ n : ℕ
a : ℕ := n + 2
ha : a ≠ 1 := succ_succ_ne_one n
⊢ ∃ p, Prime p ∧ p ∣ n + 2
state_after: no goals
Theorem: MeasureTheory.diff_cylinder_same
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

tactic: ext1 f
state_before: ι : Type u_1
α : ι → Type u_2
s : Finset ι
S T : Set ((i : { x // x ∈ s }) → α ↑i)
⊢ cylinder s S \ cylinder s T = cylinder s (S \ T)
state_after: case h
ι : Type u_1
α : ι → Type u_2
s : Finset ι
S T : Set ((i : { x // x ∈ s }) → α ↑i)
f : (i : ι) → α i
⊢ f ∈ cylinder s S \ cylinder s T ↔ f ∈ cylinder s (S \ T)

tactic: simp only [mem_diff, mem_cylinder]
state_before: case h
ι : Type u_1
α : ι → Type u_2
s : Finset ι
S T : Set ((i : { x // x ∈ s }) → α ↑i)
f : (i : ι) → α i
⊢ f ∈ cylinder s S \ cylinder s T ↔ f ∈ cylinder s (S \ T)
state_after: no goals
Theorem: Set.Definable.compl
File: Mathlib/ModelTheory/Definability.lean

tactic: rcases hf with ⟨φ, hφ⟩
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝ s : Set (α → M)
hf : A.Definable L s
⊢ A.Definable L sᶜ
state_after: case intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝ s : Set (α → M)
φ : L[[↑A]].Formula α
hφ : s = setOf φ.Realize
⊢ A.Definable L sᶜ

tactic: refine ⟨φ.not, ?_⟩
state_before: case intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝ s : Set (α → M)
φ : L[[↑A]].Formula α
hφ : s = setOf φ.Realize
⊢ A.Definable L sᶜ
state_after: case intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝ s : Set (α → M)
φ : L[[↑A]].Formula α
hφ : s = setOf φ.Realize
⊢ sᶜ = setOf φ.not.Realize

tactic: ext v
state_before: case intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝ s : Set (α → M)
φ : L[[↑A]].Formula α
hφ : s = setOf φ.Realize
⊢ sᶜ = setOf φ.not.Realize
state_after: case intro.h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝ s : Set (α → M)
φ : L[[↑A]].Formula α
hφ : s = setOf φ.Realize
v : α → M
⊢ v ∈ sᶜ ↔ v ∈ setOf φ.not.Realize

tactic: rw [hφ, compl_setOf, mem_setOf, mem_setOf, Formula.realize_not]
state_before: case intro.h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝ s : Set (α → M)
φ : L[[↑A]].Formula α
hφ : s = setOf φ.Realize
v : α → M
⊢ v ∈ sᶜ ↔ v ∈ setOf φ.not.Realize
state_after: no goals
Theorem: lowerSemicontinuousOn_univ_iff
File: Mathlib/Topology/Semicontinuous.lean

tactic: simp [LowerSemicontinuousOn, LowerSemicontinuous, lowerSemicontinuousWithinAt_univ_iff]
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
β : Type u_2
inst✝ : Preorder β
f g : α → β
x : α
s t : Set α
y z : β
⊢ LowerSemicontinuousOn f univ ↔ LowerSemicontinuous f
state_after: no goals
Theorem: SimpleGraph.Walk.reverse_reverse
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => rfl
| cons _ _ ih => simp [ih]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
⊢ p.reverse.reverse = p
state_after: no goals

tactic: rfl
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ : V
⊢ nil.reverse.reverse = nil
state_after: no goals

tactic: simp [ih]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p✝ : G.Walk v✝ w✝
ih : p✝.reverse.reverse = p✝
⊢ (cons h✝ p✝).reverse.reverse = cons h✝ p✝
state_after: no goals
Theorem: OrdinalApprox.le_lfpApprox
File: Mathlib/SetTheory/Ordinal/FixedPointApproximants.lean

tactic: unfold lfpApprox
state_before: α : Type u
inst✝ : CompleteLattice α
f : α →o α
x : α
a : Ordinal.{u}
⊢ x ≤ lfpApprox f x a
state_after: α : Type u
inst✝ : CompleteLattice α
f : α →o α
x : α
a : Ordinal.{u}
⊢ x ≤ sSup ({x_1 | ∃ b, ∃ (_ : b < a), f (lfpApprox f x b) = x_1} ∪ {x})

tactic: apply le_sSup
state_before: α : Type u
inst✝ : CompleteLattice α
f : α →o α
x : α
a : Ordinal.{u}
⊢ x ≤ sSup ({x_1 | ∃ b, ∃ (_ : b < a), f (lfpApprox f x b) = x_1} ∪ {x})
state_after: case a
α : Type u
inst✝ : CompleteLattice α
f : α →o α
x : α
a : Ordinal.{u}
⊢ x ∈ {x_1 | ∃ b, ∃ (_ : b < a), f (lfpApprox f x b) = x_1} ∪ {x}

tactic: simp only [exists_prop, Set.union_singleton, Set.mem_insert_iff, Set.mem_setOf_eq, true_or]
state_before: case a
α : Type u
inst✝ : CompleteLattice α
f : α →o α
x : α
a : Ordinal.{u}
⊢ x ∈ {x_1 | ∃ b, ∃ (_ : b < a), f (lfpApprox f x b) = x_1} ∪ {x}
state_after: no goals
Theorem: Real.tendsto_sin_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: convert continuous_sin.continuousWithinAt.tendsto
state_before: ⊢ Tendsto sin (𝓝[<] (π / 2)) (𝓝 1)
state_after: case h.e'_5.h.e'_3

⊢ 1 = sin (π / 2)

tactic: simp
state_before: case h.e'_5.h.e'_3

⊢ 1 = sin (π / 2)
state_after: no goals
Theorem: CategoryTheory.Limits.Pi.π_comp_eqToHom
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

tactic: simp [w]
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
J : Type u_1
f : J → C
inst✝ : HasProduct f
j j' : J
w : j = j'
⊢ f j = f j'
state_after: no goals

tactic: cases w
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
J : Type u_1
f : J → C
inst✝ : HasProduct f
j j' : J
w : j = j'
⊢ π f j ≫ eqToHom ⋯ = π f j'
state_after: case refl
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
J : Type u_1
f : J → C
inst✝ : HasProduct f
j : J
⊢ π f j ≫ eqToHom ⋯ = π f j

tactic: simp
state_before: case refl
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
J : Type u_1
f : J → C
inst✝ : HasProduct f
j : J
⊢ π f j ≫ eqToHom ⋯ = π f j
state_after: no goals
Theorem: intrinsicInterior_singleton
File: Mathlib/Analysis/Convex/Intrinsic.lean

tactic: simpa only [intrinsicInterior, preimage_coe_affineSpan_singleton, interior_univ, image_univ,
  Subtype.range_coe] using coe_affineSpan_singleton _ _ _
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
Q : Type u_4
P : Type u_5
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup V
inst✝² : Module 𝕜 V
inst✝¹ : TopologicalSpace P
inst✝ : AddTorsor V P
s t : Set P
x✝ x : P
⊢ intrinsicInterior 𝕜 {x} = {x}
state_after: no goals
Theorem: CategoryTheory.Limits.Trident.condition
File: Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean

tactic: rw [t.app_zero, t.app_zero]
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
j₁ j₂ : J
t : Trident f
⊢ t.ι ≫ f j₁ = t.ι ≫ f j₂
state_after: no goals
Theorem: Multiset.powersetCard_map
File: Mathlib/Data/Multiset/Powerset.lean

tactic: induction' s using Multiset.induction with t s ih generalizing n
state_before: α : Type u_1
β : Type u_2
f : α → β
n : ℕ
s : Multiset α
⊢ powersetCard n (map f s) = map (map f) (powersetCard n s)
state_after: case empty
α : Type u_1
β : Type u_2
f : α → β
n : ℕ
⊢ powersetCard n (map f 0) = map (map f) (powersetCard n 0)

case cons
α : Type u_1
β : Type u_2
f : α → β
t : α
s : Multiset α
ih : ∀ (n : ℕ), powersetCard n (map f s) = map (map f) (powersetCard n s)
n : ℕ
⊢ powersetCard n (map f (t ::ₘ s)) = map (map f) (powersetCard n (t ::ₘ s))

tactic: cases n <;> simp [powersetCard_zero_left, powersetCard_zero_right]
state_before: case empty
α : Type u_1
β : Type u_2
f : α → β
n : ℕ
⊢ powersetCard n (map f 0) = map (map f) (powersetCard n 0)
state_after: no goals

tactic: cases n <;> simp [ih, map_comp_cons]
state_before: case cons
α : Type u_1
β : Type u_2
f : α → β
t : α
s : Multiset α
ih : ∀ (n : ℕ), powersetCard n (map f s) = map (map f) (powersetCard n s)
n : ℕ
⊢ powersetCard n (map f (t ::ₘ s)) = map (map f) (powersetCard n (t ::ₘ s))
state_after: no goals
Theorem: SNum.bit_one
File: Mathlib/Data/Num/Bitwise.lean

tactic: cases b <;> rfl
state_before: b : Bool
⊢ (b::zero (decide ¬b = true)) = nz (msb b)
state_after: no goals
Theorem: IsUpperSet.div_right
File: Mathlib/Algebra/Order/UpperLower.lean

tactic: rw [div_eq_mul_inv]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
hs : IsUpperSet s
⊢ IsUpperSet (s / t)
state_after: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
hs : IsUpperSet s
⊢ IsUpperSet (s * t⁻¹)

tactic: exact hs.mul_right
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
hs : IsUpperSet s
⊢ IsUpperSet (s * t⁻¹)
state_after: no goals
Theorem: Monotone.leftLim
File: Mathlib/Topology/Order/LeftRightLim.lean

tactic: intro x y h
state_before: α : Type u_1
β : Type u_2
inst✝³ : LinearOrder α
inst✝² : ConditionallyCompleteLinearOrder β
inst✝¹ : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
hf : Monotone f
x y : α
⊢ Monotone (leftLim f)
state_after: α : Type u_1
β : Type u_2
inst✝³ : LinearOrder α
inst✝² : ConditionallyCompleteLinearOrder β
inst✝¹ : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
hf : Monotone f
x✝ y✝ x y : α
h : x ≤ y
⊢ leftLim f x ≤ leftLim f y

tactic: rcases eq_or_lt_of_le h with (rfl | hxy)
state_before: α : Type u_1
β : Type u_2
inst✝³ : LinearOrder α
inst✝² : ConditionallyCompleteLinearOrder β
inst✝¹ : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
hf : Monotone f
x✝ y✝ x y : α
h : x ≤ y
⊢ leftLim f x ≤ leftLim f y
state_after: case inl
α : Type u_1
β : Type u_2
inst✝³ : LinearOrder α
inst✝² : ConditionallyCompleteLinearOrder β
inst✝¹ : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
hf : Monotone f
x✝ y x : α
h : x ≤ x
⊢ leftLim f x ≤ leftLim f x

case inr
α : Type u_1
β : Type u_2
inst✝³ : LinearOrder α
inst✝² : ConditionallyCompleteLinearOrder β
inst✝¹ : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
hf : Monotone f
x✝ y✝ x y : α
h : x ≤ y
hxy : x < y
⊢ leftLim f x ≤ leftLim f y

tactic: exact le_rfl
state_before: case inl
α : Type u_1
β : Type u_2
inst✝³ : LinearOrder α
inst✝² : ConditionallyCompleteLinearOrder β
inst✝¹ : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
hf : Monotone f
x✝ y x : α
h : x ≤ x
⊢ leftLim f x ≤ leftLim f x
state_after: no goals

tactic: exact (hf.leftLim_le le_rfl).trans (hf.le_leftLim hxy)
state_before: case inr
α : Type u_1
β : Type u_2
inst✝³ : LinearOrder α
inst✝² : ConditionallyCompleteLinearOrder β
inst✝¹ : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
hf : Monotone f
x✝ y✝ x y : α
h : x ≤ y
hxy : x < y
⊢ leftLim f x ≤ leftLim f y
state_after: no goals
Theorem: Function.Surjective.leftDistribClass
File: Mathlib/Algebra/Ring/InjSurj.lean

tactic: simp only [← add, ← mul, left_distrib]
state_before: α : Type u_1
β : Type u_2
inst✝¹³ : Zero β
inst✝¹² : One β
inst✝¹¹ : Add β
inst✝¹⁰ : Mul β
inst✝⁹ : Neg β
inst✝⁸ : Sub β
inst✝⁷ : SMul ℕ β
inst✝⁶ : SMul ℤ β
inst✝⁵ : Pow β ℕ
inst✝⁴ : NatCast β
inst✝³ : IntCast β
f : α → β
hf : Surjective f
inst✝² : Mul α
inst✝¹ : Add α
inst✝ : LeftDistribClass α
add : ∀ (x y : α), f (x + y) = f x + f y
mul : ∀ (x y : α), f (x * y) = f x * f y
x y z : α
⊢ f x * (f y + f z) = f x * f y + f x * f z
state_after: no goals