diff --git a/app/components/types_de_champ_editor/conditions_errors_component.rb b/app/components/types_de_champ_editor/conditions_errors_component.rb
index 4ad1ea313..a4e9dae21 100644
--- a/app/components/types_de_champ_editor/conditions_errors_component.rb
+++ b/app/components/types_de_champ_editor/conditions_errors_component.rb
@@ -7,7 +7,7 @@ class TypesDeChampEditor::ConditionsErrorsComponent < ApplicationComponent
 
   def errors
     @conditions
-      .flat_map { |condition| condition.errors(@upper_tdcs.map(&:stable_id)) }
+      .flat_map { |condition| condition.errors(@upper_tdcs) }
       .map { |error| humanize(error) }
       .uniq
       .map { |message| tag.li(message) }
@@ -48,7 +48,7 @@ class TypesDeChampEditor::ConditionsErrorsComponent < ApplicationComponent
 
   def render?
     @conditions
-      .filter { |condition| condition.errors(@upper_tdcs.map(&:stable_id)).present? }
+      .filter { |condition| condition.errors(@upper_tdcs).present? }
       .present?
   end
 end
diff --git a/app/models/logic/binary_operator.rb b/app/models/logic/binary_operator.rb
index 7565a0fb9..d2df220dd 100644
--- a/app/models/logic/binary_operator.rb
+++ b/app/models/logic/binary_operator.rb
@@ -17,14 +17,14 @@ class Logic::BinaryOperator < Logic::Term
     self.new(Logic.from_h(h['left']), Logic.from_h(h['right']))
   end
 
-  def errors(stable_ids = [])
+  def errors(type_de_champs = [])
     errors = []
 
     if @left.type(type_de_champs) != :number || @right.type(type_de_champs) != :number
       errors << { type: :required_number, operator_name: self.class.name }
     end
 
-    errors + @left.errors(stable_ids) + @right.errors(stable_ids)
+    errors + @left.errors(type_de_champs) + @right.errors(type_de_champs)
   end
 
   def type(type_de_champs = []) = :boolean
diff --git a/app/models/logic/champ_value.rb b/app/models/logic/champ_value.rb
index 1b218d479..d8676ce6c 100644
--- a/app/models/logic/champ_value.rb
+++ b/app/models/logic/champ_value.rb
@@ -60,8 +60,8 @@ class Logic::ChampValue < Logic::Term
     end
   end
 
-  def errors(stable_ids)
-    if !stable_ids.include?(stable_id)
+  def errors(type_de_champs)
+    if !type_de_champs.map(&:stable_id).include?(stable_id)
       [{ type: :not_available }]
     else
       []
diff --git a/app/models/logic/constant.rb b/app/models/logic/constant.rb
index b5a0144da..084a21a18 100644
--- a/app/models/logic/constant.rb
+++ b/app/models/logic/constant.rb
@@ -29,7 +29,7 @@ class Logic::Constant < Logic::Term
     end
   end
 
-  def errors(_stable_ids = nil) = []
+  def errors(_type_de_champs = nil) = []
 
   def to_h
     {
diff --git a/app/models/logic/empty.rb b/app/models/logic/empty.rb
index 414852b1e..0b184c789 100644
--- a/app/models/logic/empty.rb
+++ b/app/models/logic/empty.rb
@@ -3,7 +3,7 @@ class Logic::Empty < Logic::Term
 
   def type(_type_de_champs = []) = :empty
 
-  def errors(_stable_ids = nil) = ['empty']
+  def errors(_type_de_champs = []) = ['empty']
 
   def to_h
     {
diff --git a/app/models/logic/empty_operator.rb b/app/models/logic/empty_operator.rb
index 26455c1e5..f8d9b7dd2 100644
--- a/app/models/logic/empty_operator.rb
+++ b/app/models/logic/empty_operator.rb
@@ -3,7 +3,7 @@ class Logic::EmptyOperator < Logic::BinaryOperator
 
   def type(_type_de_champs = []) = :empty
 
-  def errors(_stable_ids = nil) = []
+  def errors(_type_de_champs = []) = []
 
   def compute(_champs = [])
     true
diff --git a/app/models/logic/eq.rb b/app/models/logic/eq.rb
index ae3f8731c..a1f639b55 100644
--- a/app/models/logic/eq.rb
+++ b/app/models/logic/eq.rb
@@ -1,7 +1,7 @@
 class Logic::Eq < Logic::BinaryOperator
   def operation = :==
 
-  def errors(stable_ids = [])
+  def errors(type_de_champs = [])
     errors = [@left, @right]
       .filter { |term| term.type(type_de_champs) == :unmanaged }
       .map { |term| { type: :unmanaged, stable_id: term.stable_id } }
@@ -22,7 +22,7 @@ class Logic::Eq < Logic::BinaryOperator
       }
     end
 
-    errors + @left.errors(stable_ids) + @right.errors(stable_ids)
+    errors + @left.errors(type_de_champs) + @right.errors(type_de_champs)
   end
 
   def ==(other)
diff --git a/app/models/logic/include_operator.rb b/app/models/logic/include_operator.rb
index 6c0d00684..8ba53e7ce 100644
--- a/app/models/logic/include_operator.rb
+++ b/app/models/logic/include_operator.rb
@@ -1,7 +1,7 @@
 class Logic::IncludeOperator < Logic::BinaryOperator
   def operation = :include?
 
-  def errors(stable_ids = [])
+  def errors(type_de_champs = [])
     result = []
 
     if left_not_a_list?(type_de_champs)
@@ -14,7 +14,7 @@ class Logic::IncludeOperator < Logic::BinaryOperator
       }
     end
 
-    result + @left.errors(stable_ids) + @right.errors(stable_ids)
+    result + @left.errors(type_de_champs) + @right.errors(type_de_champs)
   end
 
   private
diff --git a/app/models/logic/n_ary_operator.rb b/app/models/logic/n_ary_operator.rb
index 3878637d0..0d4faa398 100644
--- a/app/models/logic/n_ary_operator.rb
+++ b/app/models/logic/n_ary_operator.rb
@@ -16,7 +16,7 @@ class Logic::NAryOperator < Logic::Term
     self.new(h['operands'].map { |operand_h| Logic.from_h(operand_h) })
   end
 
-  def errors(stable_ids = [])
+  def errors(type_de_champs = [])
     errors = []
 
     if @operands.empty?
@@ -28,7 +28,7 @@ class Logic::NAryOperator < Logic::Term
       errors += ["'#{operator_name}' ne contient pas que des booléens : #{not_booleans.map(&:to_s).join(', ')}"]
     end
 
-    errors + @operands.flat_map { |operand| operand.errors(stable_ids) }
+    errors + @operands.flat_map { |operand| operand.errors(type_de_champs) }
   end
 
   def type(_type_de_champs = []) = :boolean
diff --git a/app/models/procedure_revision.rb b/app/models/procedure_revision.rb
index 086f43412..ac4958b68 100644
--- a/app/models/procedure_revision.rb
+++ b/app/models/procedure_revision.rb
@@ -479,12 +479,12 @@ class ProcedureRevision < ApplicationRecord
   end
 
   def conditions_are_valid?
-    stable_ids = types_de_champ_public.map(&:stable_id)
+    public_tdcs = types_de_champ_public.to_a
 
-    types_de_champ_public
+    public_tdcs
       .map.with_index
       .filter_map { |tdc, i| tdc.condition.present? ? [tdc, i] : nil }
-      .map { |tdc, i| [tdc, tdc.condition.errors(stable_ids.take(i))] }
+      .map { |tdc, i| [tdc, tdc.condition.errors(public_tdcs.take(i))] }
       .filter { |_tdc, errors| errors.present? }
       .each { |tdc, message| errors.add(:condition, message, type_de_champ: tdc) }
   end
diff --git a/spec/models/logic/champ_value_spec.rb b/spec/models/logic/champ_value_spec.rb
index 46584e6f2..51e09bf6a 100644
--- a/spec/models/logic/champ_value_spec.rb
+++ b/spec/models/logic/champ_value_spec.rb
@@ -79,7 +79,7 @@ describe Logic::ChampValue do
   describe 'errors' do
     let(:champ) { create(:champ) }
 
-    it { expect(champ_value(champ.stable_id).errors([champ.stable_id])).to be_empty }
-    it { expect(champ_value(champ.stable_id).errors(['other stable ids'])).to eq([{ type: :not_available }]) }
+    it { expect(champ_value(champ.stable_id).errors([champ.type_de_champ])).to be_empty }
+    it { expect(champ_value(champ.stable_id).errors([])).to eq([{ type: :not_available }]) }
   end
 end
diff --git a/spec/models/logic/include_operator_spec.rb b/spec/models/logic/include_operator_spec.rb
index 3583a720b..5697c1f2d 100644
--- a/spec/models/logic/include_operator_spec.rb
+++ b/spec/models/logic/include_operator_spec.rb
@@ -9,7 +9,7 @@ describe Logic::IncludeOperator do
   end
 
   describe '#errors' do
-    it { expect(ds_include(champ_value(champ.stable_id), constant('val1')).errors([champ.stable_id])).to be_empty }
+    it { expect(ds_include(champ_value(champ.stable_id), constant('val1')).errors([champ.type_de_champ])).to be_empty }
     it do
       expected = {
         right: constant('something else'),
@@ -17,10 +17,10 @@ describe Logic::IncludeOperator do
         type: :not_included
       }
 
-      expect(ds_include(champ_value(champ.stable_id), constant('something else')).errors([champ.stable_id])).to eq([expected])
+      expect(ds_include(champ_value(champ.stable_id), constant('something else')).errors([champ.type_de_champ])).to eq([expected])
     end
 
-    it { expect(ds_include(constant(1), constant('val1')).errors).to eq([{ type: :required_list }]) }
+    it { expect(ds_include(constant(1), constant('val1')).errors([])).to eq([{ type: :required_list }]) }
   end
 
   describe '#==' do