ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: SimpleGraph.adj_iff_exists_edge
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
v w : V
⊢ G.Adj v w ↔ v ≠ w ∧ ∃ e ∈ G.edgeSet, v ∈ e ∧ w ∈ e
state_after: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
v w : V
⊢ (v ≠ w ∧ ∃ e ∈ G.edgeSet, v ∈ e ∧ w ∈ e) → G.Adj v w
tactic: refine ⟨fun _ => ⟨G.ne_of_adj ‹_›, s(v, w), by simpa⟩, ?_⟩
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
v w : V
⊢ (v ≠ w ∧ ∃ e ∈ G.edgeSet, v ∈ e ∧ w ∈ e) → G.Adj v w
state_after: case intro.intro.intro
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e✝ : Sym2 V
G₁ G₂ : SimpleGraph V
v w : V
hne : v ≠ w
e : Sym2 V
he : e ∈ G.edgeSet
hv : v ∈ e ∧ w ∈ e
⊢ G.Adj v w
tactic: rintro ⟨hne, e, he, hv⟩
state_before: case intro.intro.intro
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e✝ : Sym2 V
G₁ G₂ : SimpleGraph V
v w : V
hne : v ≠ w
e : Sym2 V
he : e ∈ G.edgeSet
hv : v ∈ e ∧ w ∈ e
⊢ G.Adj v w
state_after: case intro.intro.intro
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e✝ : Sym2 V
G₁ G₂ : SimpleGraph V
v w : V
hne : v ≠ w
e : Sym2 V
he : e ∈ G.edgeSet
hv : e = s(v, w)
⊢ G.Adj v w
tactic: rw [Sym2.mem_and_mem_iff hne] at hv
state_before: case intro.intro.intro
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e✝ : Sym2 V
G₁ G₂ : SimpleGraph V
v w : V
hne : v ≠ w
e : Sym2 V
he : e ∈ G.edgeSet
hv : e = s(v, w)
⊢ G.Adj v w
state_after: case intro.intro.intro
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
v w : V
hne : v ≠ w
he : s(v, w) ∈ G.edgeSet
⊢ G.Adj v w
tactic: subst e
state_before: case intro.intro.intro
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
v w : V
hne : v ≠ w
he : s(v, w) ∈ G.edgeSet
⊢ G.Adj v w
state_after: no goals
tactic: rwa [mem_edgeSet] at he
Theorem: SubgroupClass.coe_inclusion
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
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
M : Type u_5
S : Type u_6
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H✝ K✝ : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
H K : S
h : H ≤ K
a : ↥H
⊢ ↑((inclusion h) a) = ↑a
state_after: case mk
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
M : Type u_5
S : Type u_6
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H✝ K✝ : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
H K : S
h : H ≤ K
val✝ : G
property✝ : val✝ ∈ H
⊢ ↑((inclusion h) ⟨val✝, property✝⟩) = ↑⟨val✝, property✝⟩
tactic: cases a
state_before: case mk
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
M : Type u_5
S : Type u_6
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H✝ K✝ : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
H K : S
h : H ≤ K
val✝ : G
property✝ : val✝ ∈ H
⊢ ↑((inclusion h) ⟨val✝, property✝⟩) = ↑⟨val✝, property✝⟩
state_after: no goals
tactic: simp only [inclusion, MonoidHom.mk'_apply]
Theorem: CategoryTheory.mono_of_mono
File: Mathlib/CategoryTheory/Category/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Mono (f ≫ g)
⊢ Mono f
state_after: case right_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Mono (f ≫ g)
⊢ ∀ {Z : C} (g h : Z ⟶ X), g ≫ f = h ≫ f → g = h
tactic: constructor
state_before: case right_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Mono (f ≫ g)
⊢ ∀ {Z : C} (g h : Z ⟶ X), g ≫ f = h ≫ f → g = h
state_after: case right_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : a ≫ f = b ≫ f
⊢ a = b
tactic: intro Z a b w
state_before: case right_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : a ≫ f = b ≫ f
⊢ a = b
state_after: case right_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : (fun k => k ≫ g) (a ≫ f) = (fun k => k ≫ g) (b ≫ f)
⊢ a = b
tactic: replace w := congr_arg (fun k => k ≫ g) w
state_before: case right_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : (fun k => k ≫ g) (a ≫ f) = (fun k => k ≫ g) (b ≫ f)
⊢ a = b
state_after: case right_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : (a ≫ f) ≫ g = (b ≫ f) ≫ g
⊢ a = b
tactic: dsimp at w
state_before: case right_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : (a ≫ f) ≫ g = (b ≫ f) ≫ g
⊢ a = b
state_after: case right_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : a ≫ f ≫ g = b ≫ f ≫ g
⊢ a = b
tactic: rw [Category.assoc, Category.assoc] at w
state_before: case right_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : a ≫ f ≫ g = b ≫ f ≫ g
⊢ a = b
state_after: no goals
tactic: exact (cancel_mono _).1 w
Theorem: Submodule.map₂_span_singleton_eq_map
File: Mathlib/Algebra/Module/Submodule/Bilinear.lean

Proof steps:
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
m : M
⊢ map₂ f (span R {m}) = map (f m)
state_after: case h
ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
m : M
s : Submodule R N
⊢ map₂ f (span R {m}) s = map (f m) s
tactic: funext s
state_before: case h
ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
m : M
s : Submodule R N
⊢ map₂ f (span R {m}) s = map (f m) s
state_after: no goals
tactic: rw [← span_eq s, map₂_span_span, image2_singleton_left, map_span]
Theorem: Real.rpow_sub'
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x✝¹ y✝¹ z✝¹ w x✝ y✝ z✝ x : ℝ
hx : 0 ≤ x
y z : ℝ
h : y - z ≠ 0
⊢ x ^ (y - z) = x ^ y / x ^ z
state_after: x✝¹ y✝¹ z✝¹ w x✝ y✝ z✝ x : ℝ
hx : 0 ≤ x
y z : ℝ
h : y + -z ≠ 0
⊢ x ^ (y + -z) = x ^ y / x ^ z
tactic: simp only [sub_eq_add_neg] at h ⊢
state_before: x✝¹ y✝¹ z✝¹ w x✝ y✝ z✝ x : ℝ
hx : 0 ≤ x
y z : ℝ
h : y + -z ≠ 0
⊢ x ^ (y + -z) = x ^ y / x ^ z
state_after: no goals
tactic: simp only [rpow_add' hx h, rpow_neg hx, div_eq_mul_inv]
Theorem: MeasureTheory.Lp.edist_toLp_toLp
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : α → E
hf : Memℒp f p μ
hg : Memℒp g p μ
⊢ edist (Memℒp.toLp f hf) (Memℒp.toLp g hg) = eLpNorm (f - g) p μ
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : α → E
hf : Memℒp f p μ
hg : Memℒp g p μ
⊢ eLpNorm (↑↑(Memℒp.toLp f hf) - ↑↑(Memℒp.toLp g hg)) p μ = eLpNorm (f - g) p μ
tactic: rw [edist_def]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : α → E
hf : Memℒp f p μ
hg : Memℒp g p μ
⊢ eLpNorm (↑↑(Memℒp.toLp f hf) - ↑↑(Memℒp.toLp g hg)) p μ = eLpNorm (f - g) p μ
state_after: no goals
tactic: exact eLpNorm_congr_ae (hf.coeFn_toLp.sub hg.coeFn_toLp)
Theorem: disjoint_nhds_atBot
File: Mathlib/Topology/Order/OrderClosed.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : Preorder α
inst✝³ : NoBotOrder α
inst✝² : TopologicalSpace α
inst✝¹ : ClosedIicTopology α
a✝ : α
l : Filter β
inst✝ : l.NeBot
f : β → α
a : α
⊢ Disjoint (𝓝 a) atBot
state_after: no goals
tactic: simp
Theorem: List.take_iterate
File: Mathlib/Data/List/Iterate.lean

Proof steps:
state_before: α : Type u_1
f : α → α
a : α
m n : ℕ
⊢ take m (iterate f a n) = iterate f a (min m n)
state_after: no goals
tactic: rw [← range_map_iterate, ← range_map_iterate, ← map_take, take_range]
Theorem: Polynomial.expand_eq_C
File: Mathlib/Algebra/Polynomial/Expand.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
hp : 0 < p
f : R[X]
r : R
⊢ (expand R p) f = C r ↔ f = C r
state_after: no goals
tactic: rw [← expand_C, expand_inj hp, expand_C]
Theorem: Order.Ideal.inter_nonempty
File: Mathlib/Order/Ideal.lean

Proof steps:
state_before: P : Type u_1
inst✝¹ : LE P
I✝ J✝ s t : Ideal P
x y : P
inst✝ : IsDirected P fun x x_1 => x ≥ x_1
I J : Ideal P
⊢ (↑I ∩ ↑J).Nonempty
state_after: case intro
P : Type u_1
inst✝¹ : LE P
I✝ J✝ s t : Ideal P
x y : P
inst✝ : IsDirected P fun x x_1 => x ≥ x_1
I J : Ideal P
a : P
ha : a ∈ ↑I
⊢ (↑I ∩ ↑J).Nonempty
tactic: obtain ⟨a, ha⟩ := I.nonempty
state_before: case intro
P : Type u_1
inst✝¹ : LE P
I✝ J✝ s t : Ideal P
x y : P
inst✝ : IsDirected P fun x x_1 => x ≥ x_1
I J : Ideal P
a : P
ha : a ∈ ↑I
⊢ (↑I ∩ ↑J).Nonempty
state_after: case intro.intro
P : Type u_1
inst✝¹ : LE P
I✝ J✝ s t : Ideal P
x y : P
inst✝ : IsDirected P fun x x_1 => x ≥ x_1
I J : Ideal P
a : P
ha : a ∈ ↑I
b : P
hb : b ∈ ↑J
⊢ (↑I ∩ ↑J).Nonempty
tactic: obtain ⟨b, hb⟩ := J.nonempty
state_before: case intro.intro
P : Type u_1
inst✝¹ : LE P
I✝ J✝ s t : Ideal P
x y : P
inst✝ : IsDirected P fun x x_1 => x ≥ x_1
I J : Ideal P
a : P
ha : a ∈ ↑I
b : P
hb : b ∈ ↑J
⊢ (↑I ∩ ↑J).Nonempty
state_after: case intro.intro.intro.intro
P : Type u_1
inst✝¹ : LE P
I✝ J✝ s t : Ideal P
x y : P
inst✝ : IsDirected P fun x x_1 => x ≥ x_1
I J : Ideal P
a : P
ha : a ∈ ↑I
b : P
hb : b ∈ ↑J
c : P
hac : c ≤ a
hbc : c ≤ b
⊢ (↑I ∩ ↑J).Nonempty
tactic: obtain ⟨c, hac, hbc⟩ := exists_le_le a b
state_before: case intro.intro.intro.intro
P : Type u_1
inst✝¹ : LE P
I✝ J✝ s t : Ideal P
x y : P
inst✝ : IsDirected P fun x x_1 => x ≥ x_1
I J : Ideal P
a : P
ha : a ∈ ↑I
b : P
hb : b ∈ ↑J
c : P
hac : c ≤ a
hbc : c ≤ b
⊢ (↑I ∩ ↑J).Nonempty
state_after: no goals
tactic: exact ⟨c, I.lower hac ha, J.lower hbc hb⟩
Theorem: SchwartzMap.isBigO_cocompact_zpow
File: Mathlib/Analysis/Distribution/SchwartzSpace.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
f : 𝓢(E, F)
inst✝ : ProperSpace E
k : ℤ
⊢ ⇑f =O[cocompact E] fun x => ‖x‖ ^ k
state_after: no goals
tactic: simpa only [Real.rpow_intCast] using isBigO_cocompact_rpow f k
Theorem: ChainClosure.succ_fixpoint
File: Mathlib/Order/Chain.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hc₁ : ChainClosure r c₁
hc₂ : ChainClosure r c₂
hc : SuccChain r c₂ = c₂
⊢ c₁ ⊆ c₂
state_after: no goals
tactic: induction hc₁ with
  | succ hc₁ h => exact (chainClosure_succ_total hc₁ hc₂ h).elim (fun h => h ▸ hc.subset) id
  | union _ ih => exact sUnion_subset ih
Theorem: List.nodup_cons
File: Mathlib/Data/List/Nodup.lean

Proof steps:
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b a : α
l : List α
⊢ (a :: l).Nodup ↔ a ∉ l ∧ l.Nodup
state_after: no goals
tactic: simp only [Nodup, pairwise_cons, forall_mem_ne]
Theorem: List.append_sublist_append_right
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α✝ : Type u_1
l₁ l₂ l : List α✝
h : l₁ ++ l <+ l₂ ++ l
⊢ l₁ <+ l₂
state_after: α✝ : Type u_1
l₁ l₂ l : List α✝
h : l₁ ++ l <+ l₂ ++ l
this : (l₁ ++ l).reverse <+ (l₂ ++ l).reverse
⊢ l₁ <+ l₂
tactic: have := h.reverse
state_before: α✝ : Type u_1
l₁ l₂ l : List α✝
h : l₁ ++ l <+ l₂ ++ l
this : (l₁ ++ l).reverse <+ (l₂ ++ l).reverse
⊢ l₁ <+ l₂
state_after: α✝ : Type u_1
l₁ l₂ l : List α✝
h : l₁ ++ l <+ l₂ ++ l
this : l₁ <+ l₂
⊢ l₁ <+ l₂
tactic: simp only [reverse_append, append_sublist_append_left, reverse_sublist] at this
state_before: α✝ : Type u_1
l₁ l₂ l : List α✝
h : l₁ ++ l <+ l₂ ++ l
this : l₁ <+ l₂
⊢ l₁ <+ l₂
state_after: no goals
tactic: exact this
Theorem: FirstOrder.Language.BoundedFormula.realize_toFormula
File: Mathlib/ModelTheory/Semantics.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
φ : L.BoundedFormula α n
v : α ⊕ Fin n → M
⊢ φ.toFormula.Realize v ↔ φ.Realize (v ∘ Sum.inl) (v ∘ Sum.inr)
state_after: case falsum
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
n✝ : ℕ
v : α ⊕ Fin n✝ → M
⊢ falsum.toFormula.Realize v ↔ falsum.Realize (v ∘ Sum.inl) (v ∘ Sum.inr)

case equal
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
n✝ : ℕ
t₁✝ t₂✝ : L.Term (α ⊕ Fin n✝)
v : α ⊕ Fin n✝ → M
⊢ (equal t₁✝ t₂✝).toFormula.Realize v ↔ (equal t₁✝ t₂✝).Realize (v ∘ Sum.inl) (v ∘ Sum.inr)

case rel
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
n✝ l✝ : ℕ
R✝ : L.Relations l✝
ts✝ : Fin l✝ → L.Term (α ⊕ Fin n✝)
v : α ⊕ Fin n✝ → M
⊢ (rel R✝ ts✝).toFormula.Realize v ↔ (rel R✝ ts✝).Realize (v ∘ Sum.inl) (v ∘ Sum.inr)

case imp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
n✝ : ℕ
f₁✝ f₂✝ : L.BoundedFormula α n✝
ih1 : ∀ (v : α ⊕ Fin n✝ → M), f₁✝.toFormula.Realize v ↔ f₁✝.Realize (v ∘ Sum.inl) (v ∘ Sum.inr)
ih2 : ∀ (v : α ⊕ Fin n✝ → M), f₂✝.toFormula.Realize v ↔ f₂✝.Realize (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
⊢ (f₁✝ ⟹ f₂✝).toFormula.Realize v ↔ (f₁✝ ⟹ f₂✝).Realize (v ∘ Sum.inl) (v ∘ Sum.inr)

case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
n✝ : ℕ
f✝ : L.BoundedFormula α (n✝ + 1)
ih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), f✝.toFormula.Realize v ↔ f✝.Realize (v ∘ Sum.inl) (v ∘ Sum.inr)
v : α ⊕ Fin n✝ → M
⊢ (∀'f✝).toFormula.Realize v ↔ (∀'f✝).Realize (v ∘ Sum.inl) (v ∘ Sum.inr)
tactic: induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 _ _ ih3 a8 a9 a0
Theorem: Filter.mem_interior
File: Mathlib/Topology/Filter.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
X : Type u_4
Y : Type u_5
s : Set (Filter α)
l : Filter α
⊢ l ∈ interior s ↔ ∃ t ∈ l, Iic (𝓟 t) ⊆ s
state_after: no goals
tactic: rw [mem_interior_iff_mem_nhds, Filter.mem_nhds_iff]
Theorem: FiniteDimensional.finrank_mul_finrank
File: Mathlib/LinearAlgebra/Dimension/Free.lean

Proof steps:
state_before: F : Type u
K : Type v
A : Type w
inst✝¹⁰ : Ring F
inst✝⁹ : Ring K
inst✝⁸ : AddCommGroup A
inst✝⁷ : Module F K
inst✝⁶ : Module K A
inst✝⁵ : Module F A
inst✝⁴ : IsScalarTower F K A
inst✝³ : StrongRankCondition F
inst✝² : StrongRankCondition K
inst✝¹ : Module.Free F K
inst✝ : Module.Free K A
⊢ finrank F K * finrank K A = finrank F A
state_after: F : Type u
K : Type v
A : Type w
inst✝¹⁰ : Ring F
inst✝⁹ : Ring K
inst✝⁸ : AddCommGroup A
inst✝⁷ : Module F K
inst✝⁶ : Module K A
inst✝⁵ : Module F A
inst✝⁴ : IsScalarTower F K A
inst✝³ : StrongRankCondition F
inst✝² : StrongRankCondition K
inst✝¹ : Module.Free F K
inst✝ : Module.Free K A
⊢ toNat (Module.rank F K) * toNat (Module.rank K A) = toNat (Module.rank F A)
tactic: simp_rw [finrank]
state_before: F : Type u
K : Type v
A : Type w
inst✝¹⁰ : Ring F
inst✝⁹ : Ring K
inst✝⁸ : AddCommGroup A
inst✝⁷ : Module F K
inst✝⁶ : Module K A
inst✝⁵ : Module F A
inst✝⁴ : IsScalarTower F K A
inst✝³ : StrongRankCondition F
inst✝² : StrongRankCondition K
inst✝¹ : Module.Free F K
inst✝ : Module.Free K A
⊢ toNat (Module.rank F K) * toNat (Module.rank K A) = toNat (Module.rank F A)
state_after: no goals
tactic: rw [← toNat_lift.{w} (Module.rank F K), ← toNat_lift.{v} (Module.rank K A), ← toNat_mul,
    lift_rank_mul_lift_rank, toNat_lift]
Theorem: CategoryTheory.Limits.epi_of_target_iso_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : Y ≅ 0
Z : C
g h : Y ⟶ Z
x✝ : f ≫ g = f ≫ h
⊢ g = h
state_after: no goals
tactic: rw [zero_of_source_iso_zero g i, zero_of_source_iso_zero h i]
Theorem: Nat.size_le
File: Mathlib/Data/Nat/Size.lean

Proof steps:
state_before: m n : ℕ
h : m.size ≤ n
⊢ 2 > 0
state_after: no goals
tactic: decide
state_before: m n : ℕ
⊢ m < 2 ^ n → m.size ≤ n
state_after: m n : ℕ
⊢ m < 1 <<< n → m.size ≤ n
tactic: rw [← one_shiftLeft]
state_before: m n : ℕ
⊢ m < 1 <<< n → m.size ≤ n
state_after: m : ℕ
⊢ ∀ {n : ℕ}, m < 1 <<< n → m.size ≤ n
tactic: revert n
state_before: m : ℕ
⊢ ∀ {n : ℕ}, m < 1 <<< n → m.size ≤ n
state_after: m : ℕ
⊢ ∀ {n : ℕ}, 0 < 1 <<< n → size 0 ≤ n

m : ℕ
⊢ ∀ (b : Bool) (n : ℕ),
    (∀ {n_1 : ℕ}, n < 1 <<< n_1 → n.size ≤ n_1) → ∀ {n_1 : ℕ}, bit b n < 1 <<< n_1 → (bit b n).size ≤ n_1
tactic: apply binaryRec _ _ m
Theorem: CFC.exists_sqrt_of_isSelfAdjoint_of_spectrumRestricts
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Instances.lean

Proof steps:
state_before: A : Type u_1
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : TopologicalSpace A
inst✝¹ : Algebra ℝ A
inst✝ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
a : A
ha₁ : IsSelfAdjoint a
ha₂ : SpectrumRestricts a ⇑ContinuousMap.realToNNReal
⊢ ∃ x, IsSelfAdjoint x ∧ SpectrumRestricts x ⇑ContinuousMap.realToNNReal ∧ x ^ 2 = a
state_after: case right
A : Type u_1
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : TopologicalSpace A
inst✝¹ : Algebra ℝ A
inst✝ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
a : A
ha₁ : IsSelfAdjoint a
ha₂ : SpectrumRestricts a ⇑ContinuousMap.realToNNReal
⊢ SpectrumRestricts (cfc Real.sqrt a) ⇑ContinuousMap.realToNNReal ∧ cfc Real.sqrt a ^ 2 = a
tactic: use cfc Real.sqrt a, cfc_predicate Real.sqrt a
state_before: case right
A : Type u_1
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : TopologicalSpace A
inst✝¹ : Algebra ℝ A
inst✝ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
a : A
ha₁ : IsSelfAdjoint a
ha₂ : SpectrumRestricts a ⇑ContinuousMap.realToNNReal
⊢ SpectrumRestricts (cfc Real.sqrt a) ⇑ContinuousMap.realToNNReal ∧ cfc Real.sqrt a ^ 2 = a
state_after: case right.left
A : Type u_1
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : TopologicalSpace A
inst✝¹ : Algebra ℝ A
inst✝ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
a : A
ha₁ : IsSelfAdjoint a
ha₂ : SpectrumRestricts a ⇑ContinuousMap.realToNNReal
⊢ SpectrumRestricts (cfc Real.sqrt a) ⇑ContinuousMap.realToNNReal

case right.right
A : Type u_1
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : TopologicalSpace A
inst✝¹ : Algebra ℝ A
inst✝ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
a : A
ha₁ : IsSelfAdjoint a
ha₂ : SpectrumRestricts a ⇑ContinuousMap.realToNNReal
⊢ cfc Real.sqrt a ^ 2 = a
tactic: constructor
Theorem: IsLocalization.algebraMap_mk'
File: Mathlib/RingTheory/Localization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹² : CommRing R
M : Submonoid R
S : Type u_2
inst✝¹¹ : CommRing S
inst✝¹⁰ : Algebra R S
P : Type u_3
inst✝⁹ : CommRing P
Rₘ : Type u_4
Sₘ : Type u_5
inst✝⁸ : CommRing Rₘ
inst✝⁷ : CommRing Sₘ
inst✝⁶ : Algebra R Rₘ
inst✝⁵ : IsLocalization M Rₘ
inst✝⁴ : Algebra S Sₘ
i : IsLocalization (Algebra.algebraMapSubmonoid S M) Sₘ
inst✝³ : Algebra Rₘ Sₘ
inst✝² : Algebra R Sₘ
inst✝¹ : IsScalarTower R Rₘ Sₘ
inst✝ : IsScalarTower R S Sₘ
x : R
y : ↥M
⊢ (algebraMap Rₘ Sₘ) (mk' Rₘ x y) = mk' Sₘ ((algebraMap R S) x) ⟨(algebraMap R S) ↑y, ⋯⟩
state_after: R : Type u_1
inst✝¹² : CommRing R
M : Submonoid R
S : Type u_2
inst✝¹¹ : CommRing S
inst✝¹⁰ : Algebra R S
P : Type u_3
inst✝⁹ : CommRing P
Rₘ : Type u_4
Sₘ : Type u_5
inst✝⁸ : CommRing Rₘ
inst✝⁷ : CommRing Sₘ
inst✝⁶ : Algebra R Rₘ
inst✝⁵ : IsLocalization M Rₘ
inst✝⁴ : Algebra S Sₘ
i : IsLocalization (Algebra.algebraMapSubmonoid S M) Sₘ
inst✝³ : Algebra Rₘ Sₘ
inst✝² : Algebra R Sₘ
inst✝¹ : IsScalarTower R Rₘ Sₘ
inst✝ : IsScalarTower R S Sₘ
x : R
y : ↥M
⊢ (algebraMap Rₘ Sₘ) (mk' Rₘ (↑y * x) y) = (algebraMap Rₘ Sₘ) ((algebraMap R Rₘ) x)
tactic: rw [IsLocalization.eq_mk'_iff_mul_eq, Subtype.coe_mk, ← IsScalarTower.algebraMap_apply, ←
    IsScalarTower.algebraMap_apply, IsScalarTower.algebraMap_apply R Rₘ Sₘ,
    IsScalarTower.algebraMap_apply R Rₘ Sₘ, ← _root_.map_mul, mul_comm,
    IsLocalization.mul_mk'_eq_mk'_of_mul]
state_before: R : Type u_1
inst✝¹² : CommRing R
M : Submonoid R
S : Type u_2
inst✝¹¹ : CommRing S
inst✝¹⁰ : Algebra R S
P : Type u_3
inst✝⁹ : CommRing P
Rₘ : Type u_4
Sₘ : Type u_5
inst✝⁸ : CommRing Rₘ
inst✝⁷ : CommRing Sₘ
inst✝⁶ : Algebra R Rₘ
inst✝⁵ : IsLocalization M Rₘ
inst✝⁴ : Algebra S Sₘ
i : IsLocalization (Algebra.algebraMapSubmonoid S M) Sₘ
inst✝³ : Algebra Rₘ Sₘ
inst✝² : Algebra R Sₘ
inst✝¹ : IsScalarTower R Rₘ Sₘ
inst✝ : IsScalarTower R S Sₘ
x : R
y : ↥M
⊢ (algebraMap Rₘ Sₘ) (mk' Rₘ (↑y * x) y) = (algebraMap Rₘ Sₘ) ((algebraMap R Rₘ) x)
state_after: no goals
tactic: exact congr_arg (algebraMap Rₘ Sₘ) (IsLocalization.mk'_mul_cancel_left x y)